eel-editable-label.c

1

/* CTK - The GIMP Toolkit

2

3

*

4

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

5

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

6

* License as published by the Free Software Foundation; either

7

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

8

*

9

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

10

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

11

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

12

* Lesser General Public License for more details.

13

*

14

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

15

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

16

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

17

*/

18

19

/*

20

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

21

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

22

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

23

* CTK+ at ftp://ftp.ctk.org/pub/ctk/.

24

*/

25

26

#include <config.h>

27

#include <math.h>

28

#include <string.h>

29

30

#include "eel-editable-label.h"

31

#include "eel-marshal.h"

32

#include "eel-accessibility.h"

33

#include "eel-ctk-extensions.h"

34

35

#include <libcail-util/cailmisc.h>

36

37

#include <glib/gi18n-lib.h>

38

#include <pango/pango.h>

39

#include <ctk/ctk.h>

40

#include <ctk/ctk-a11y.h>

41

#include <cdk/cdkx.h>

42

#include <cdk/cdkkeysyms.h>

43

44

#ifndef PANGO_CHECK_VERSION

45

#define PANGO_CHECK_VERSION(major, minor, micro)(1 > (major) || (1 == (major) && 58 > (minor)) ||
(1 == (major) && 58 == (minor) && 0 >= (micro
))) \

46

(PANGO_VERSION_MAJOR1 > (major) || \

47

(PANGO_VERSION_MAJOR1 == (major) && PANGO_VERSION_MINOR58 > (minor)) || \

48

(PANGO_VERSION_MAJOR1 == (major) && PANGO_VERSION_MINOR58 == (minor) && \

49

PANGO_VERSION_MICRO0 >= (micro)))

50

#endif

51

52

53

enum

54

{

55

MOVE_CURSOR,

56

POPULATE_POPUP,

57

DELETE_FROM_CURSOR,

58

CUT_CLIPBOARD,

59

COPY_CLIPBOARD,

60

PASTE_CLIPBOARD,

61

TOGGLE_OVERWRITE,

62

LAST_SIGNAL

63

};

64

65

enum

66

{

67

PROP_0,

68

PROP_TEXT,

69

PROP_JUSTIFY,

70

PROP_WRAP,

71

PROP_CURSOR_POSITION,

72

PROP_SELECTION_BOUND

73

};

74

75

static guint signals[LAST_SIGNAL] = { 0 };

76

77

static void eel_editable_label_editable_init (CtkEditableInterface *iface);

78

static void eel_editable_label_set_property (GObject *object,

79

guint prop_id,

80

const GValue *value,

81

GParamSpec *pspec);

82

static void eel_editable_label_get_property (GObject *object,

83

guint prop_id,

84

GValue *value,

85

GParamSpec *pspec);

86

static void eel_editable_label_finalize (GObject *object);

87

88

static void eel_editable_label_get_preferred_width (CtkWidget *widget,

89

gint *minimum,

90

gint *natural);

91

static void eel_editable_label_get_preferred_height (CtkWidget *widget,

92

gint *minimum,

93

gint *natural);

94

95

static void eel_editable_label_size_allocate (CtkWidget *widget,

96

CtkAllocation *allocation);

97

static void eel_editable_label_state_changed (CtkWidget *widget,

98

CtkStateType state);

99

100

static void eel_editable_label_style_updated (CtkWidget *widget);

101

102

static void eel_editable_label_direction_changed (CtkWidget *widget,

103

CtkTextDirection previous_dir);

104

105

static gint eel_editable_label_draw (CtkWidget *widget,

106

cairo_t *cr);

107

108

static void eel_editable_label_realize (CtkWidget *widget);

109

static void eel_editable_label_unrealize (CtkWidget *widget);

110

static void eel_editable_label_map (CtkWidget *widget);

111

static void eel_editable_label_unmap (CtkWidget *widget);

112

static gint eel_editable_label_button_press (CtkWidget *widget,

113

CdkEventButton *event);

114

static gint eel_editable_label_button_release (CtkWidget *widget,

115

CdkEventButton *event);

116

static gint eel_editable_label_motion (CtkWidget *widget,

117

CdkEventMotion *event);

118

static gint eel_editable_label_key_press (CtkWidget *widget,

119

CdkEventKey *event);

120

static gint eel_editable_label_key_release (CtkWidget *widget,

121

CdkEventKey *event);

122

static gint eel_editable_label_focus_in (CtkWidget *widget,

123

CdkEventFocus *event);

124

static gint eel_editable_label_focus_out (CtkWidget *widget,

125

CdkEventFocus *event);

126

static GType eel_editable_label_accessible_get_type (void);

127

128

static void eel_editable_label_commit_cb (CtkIMContext *context,

129

const gchar *str,

130

EelEditableLabel *label);

131

static void eel_editable_label_preedit_changed_cb (CtkIMContext *context,

132

EelEditableLabel *label);

133

static gboolean eel_editable_label_retrieve_surrounding_cb (CtkIMContext *context,

134

EelEditableLabel *label);

135

static gboolean eel_editable_label_delete_surrounding_cb (CtkIMContext *slave,

136

gint offset,

137

gint n_chars,

138

EelEditableLabel *label);

139

static void eel_editable_label_clear_layout (EelEditableLabel *label);

140

static void eel_editable_label_recompute (EelEditableLabel *label);

141

static void eel_editable_label_ensure_layout (EelEditableLabel *label,

142

gboolean include_preedit);

143

static void eel_editable_label_select_region_index (EelEditableLabel *label,

144

gint anchor_index,

145

gint end_index);

146

static gboolean eel_editable_label_focus (CtkWidget *widget,

147

CtkDirectionType direction);

148

static void eel_editable_label_move_cursor (EelEditableLabel *label,

149

CtkMovementStep step,

150

gint count,

151

gboolean extend_selection);

152

static void eel_editable_label_delete_from_cursor (EelEditableLabel *label,

153

CtkDeleteType type,

154

gint count);

155

static void eel_editable_label_copy_clipboard (EelEditableLabel *label);

156

static void eel_editable_label_cut_clipboard (EelEditableLabel *label);

157

static void eel_editable_label_paste (EelEditableLabel *label,

158

CdkAtom selection);

159

static void eel_editable_label_paste_clipboard (EelEditableLabel *label);

160

static void eel_editable_label_select_all (EelEditableLabel *label);

161

static void eel_editable_label_do_popup (EelEditableLabel *label,

162

CdkEventButton *event);

163

static void eel_editable_label_toggle_overwrite (EelEditableLabel *label);

164

static gint eel_editable_label_move_forward_word (EelEditableLabel *label,

165

gint start);

166

static gint eel_editable_label_move_backward_word (EelEditableLabel *label,

167

gint start);

168

static void eel_editable_label_reset_im_context (EelEditableLabel *label);

169

static void eel_editable_label_check_cursor_blink (EelEditableLabel *label);

170

static void eel_editable_label_pend_cursor_blink (EelEditableLabel *label);

171

172

/* Editable implementation: */

173

static void editable_insert_text_emit (CtkEditable *editable,

174

const gchar *new_text,

175

gint new_text_length,

176

gint *position);

177

static void editable_delete_text_emit (CtkEditable *editable,

178

gint start_pos,

179

gint end_pos);

180

static void editable_insert_text (CtkEditable *editable,

181

const gchar *new_text,

182

gint new_text_length,

183

gint *position);

184

static void editable_delete_text (CtkEditable *editable,

185

gint start_pos,

186

gint end_pos);

187

static gchar * editable_get_chars (CtkEditable *editable,

188

gint start_pos,

189

gint end_pos);

190

static void editable_set_selection_bounds (CtkEditable *editable,

191

gint start,

192

gint end);

193

static gboolean editable_get_selection_bounds (CtkEditable *editable,

194

gint *start,

195

gint *end);

196

static void editable_real_set_position (CtkEditable *editable,

197

gint position);

198

static gint editable_get_position (CtkEditable *editable);

199

200

G_DEFINE_TYPE_WITH_CODE (EelEditableLabel, eel_editable_label, CTK_TYPE_WIDGET,static void eel_editable_label_init (EelEditableLabel *self);
static void eel_editable_label_class_init (EelEditableLabelClass
*klass); static GType eel_editable_label_get_type_once (void
); static gpointer eel_editable_label_parent_class = ((void*)
0); static gint EelEditableLabel_private_offset; static void eel_editable_label_class_intern_init
(gpointer klass) { eel_editable_label_parent_class = g_type_class_peek_parent
(klass); if (EelEditableLabel_private_offset != 0) g_type_class_adjust_private_offset
(klass, &EelEditableLabel_private_offset); eel_editable_label_class_init
((EelEditableLabelClass*) klass); } __attribute__ ((__unused__
)) static inline gpointer eel_editable_label_get_instance_private
(EelEditableLabel *self) { return (((gpointer) ((guint8*) (self
) + (glong) (EelEditableLabel_private_offset)))); } GType eel_editable_label_get_type
(void) { static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_get_type_once (); (__extension__ ({ _Static_assert
(sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType eel_editable_label_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_get_type ()), g_intern_static_string ("EelEditableLabel"
), sizeof (EelEditableLabelClass), (GClassInitFunc)(void (*)(
void)) eel_editable_label_class_intern_init, sizeof (EelEditableLabel
), (GInstanceInitFunc)(void (*)(void)) eel_editable_label_init
, (GTypeFlags) 0); { {{ const GInterfaceInfo g_implement_interface_info
= { (GInterfaceInitFunc)(void (*)(void)) eel_editable_label_editable_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (ctk_editable_get_type ()), &g_implement_interface_info
); };} } return g_define_type_id; }

201

202

G_IMPLEMENT_INTERFACE (CTK_TYPE_EDITABLE, eel_editable_label_editable_init))static void eel_editable_label_init (EelEditableLabel *self);
static void eel_editable_label_class_init (EelEditableLabelClass
*klass); static GType eel_editable_label_get_type_once (void
); static gpointer eel_editable_label_parent_class = ((void*)
0); static gint EelEditableLabel_private_offset; static void eel_editable_label_class_intern_init
(gpointer klass) { eel_editable_label_parent_class = g_type_class_peek_parent
(klass); if (EelEditableLabel_private_offset != 0) g_type_class_adjust_private_offset
(klass, &EelEditableLabel_private_offset); eel_editable_label_class_init
((EelEditableLabelClass*) klass); } __attribute__ ((__unused__
)) static inline gpointer eel_editable_label_get_instance_private
(EelEditableLabel *self) { return (((gpointer) ((guint8*) (self
) + (glong) (EelEditableLabel_private_offset)))); } GType eel_editable_label_get_type
(void) { static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_get_type_once (); (__extension__ ({ _Static_assert
(sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType eel_editable_label_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_get_type ()), g_intern_static_string ("EelEditableLabel"
), sizeof (EelEditableLabelClass), (GClassInitFunc)(void (*)(
void)) eel_editable_label_class_intern_init, sizeof (EelEditableLabel
), (GInstanceInitFunc)(void (*)(void)) eel_editable_label_init
, (GTypeFlags) 0); { {{ const GInterfaceInfo g_implement_interface_info
= { (GInterfaceInitFunc)(void (*)(void)) eel_editable_label_editable_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (ctk_editable_get_type ()), &g_implement_interface_info
); };} } return g_define_type_id; };

203

204

static void

205

add_move_binding (CtkBindingSet *binding_set,

206

guint keyval,

207

guint modmask,

208

CtkMovementStep step,

209

gint count)

210

{

211

g_assert ((modmask & CDK_SHIFT_MASK) == 0)do { if ((modmask & CDK_SHIFT_MASK) == 0) ; else g_assertion_message_expr
("Eel", "eel-editable-label.c", 211, ((const char*) (__func__
)), "(modmask & CDK_SHIFT_MASK) == 0"); } while (0);

212

213

ctk_binding_entry_add_signal (binding_set, keyval, modmask,

214

"move_cursor", 3,

215

G_TYPE_ENUM((GType) ((12) << (2))), step,

216

G_TYPE_INT((GType) ((6) << (2))), count,

217

G_TYPE_BOOLEAN((GType) ((5) << (2))), FALSE(0));

218

219

/* Selection-extending version */

220

ctk_binding_entry_add_signal (binding_set, keyval, modmask | CDK_SHIFT_MASK,

221

"move_cursor", 3,

222

G_TYPE_ENUM((GType) ((12) << (2))), step,

223

G_TYPE_INT((GType) ((6) << (2))), count,

224

G_TYPE_BOOLEAN((GType) ((5) << (2))), TRUE(!(0)));

225

}

226

227

static void

228

eel_editable_label_class_init (EelEditableLabelClass *class)

229

{

230

GObjectClass *gobject_class = G_OBJECT_CLASS (class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((class)), (((GType) ((20) << (2))))))));

231

CtkWidgetClass *widget_class = CTK_WIDGET_CLASS (class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((class)), ((ctk_widget_get_type ()))))));

232

CtkBindingSet *binding_set;

233

234

gobject_class->set_property = eel_editable_label_set_property;

235

gobject_class->get_property = eel_editable_label_get_property;

236

gobject_class->finalize = eel_editable_label_finalize;

237

238

239

widget_class->get_preferred_width = eel_editable_label_get_preferred_width;

240

widget_class->get_preferred_height = eel_editable_label_get_preferred_height;

241

widget_class->size_allocate = eel_editable_label_size_allocate;

242

widget_class->state_changed = eel_editable_label_state_changed;

243

widget_class->style_updated = eel_editable_label_style_updated;

244

widget_class->direction_changed = eel_editable_label_direction_changed;

245

widget_class->draw = eel_editable_label_draw;

246

widget_class->realize = eel_editable_label_realize;

247

widget_class->unrealize = eel_editable_label_unrealize;

248

widget_class->map = eel_editable_label_map;

249

widget_class->unmap = eel_editable_label_unmap;

250

widget_class->button_press_event = eel_editable_label_button_press;

251

widget_class->button_release_event = eel_editable_label_button_release;

252

widget_class->motion_notify_event = eel_editable_label_motion;

253

widget_class->focus = eel_editable_label_focus;

254

widget_class->key_press_event = eel_editable_label_key_press;

255

widget_class->key_release_event = eel_editable_label_key_release;

256

widget_class->focus_in_event = eel_editable_label_focus_in;

257

widget_class->focus_out_event = eel_editable_label_focus_out;

258

ctk_widget_class_set_accessible_type (widget_class, eel_editable_label_accessible_get_type ());

259

260

261

class->move_cursor = eel_editable_label_move_cursor;

262

class->delete_from_cursor = eel_editable_label_delete_from_cursor;

263

class->copy_clipboard = eel_editable_label_copy_clipboard;

264

class->cut_clipboard = eel_editable_label_cut_clipboard;

265

class->paste_clipboard = eel_editable_label_paste_clipboard;

266

class->toggle_overwrite = eel_editable_label_toggle_overwrite;

267

268

signals[MOVE_CURSOR] =

269

g_signal_new ("move_cursor",

270

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

271

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

272

G_STRUCT_OFFSET (EelEditableLabelClass, move_cursor)((glong) __builtin_offsetof(EelEditableLabelClass, move_cursor
)),

273

NULL((void*)0), NULL((void*)0),

274

eel_marshal_VOID__ENUM_INT_BOOLEAN,

275

G_TYPE_NONE((GType) ((1) << (2))), 3, CTK_TYPE_MOVEMENT_STEP(ctk_movement_step_get_type ()), G_TYPE_INT((GType) ((6) << (2))), G_TYPE_BOOLEAN((GType) ((5) << (2))));

276

277

signals[COPY_CLIPBOARD] =

278

g_signal_new ("copy_clipboard",

279

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

280

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

281

G_STRUCT_OFFSET (EelEditableLabelClass, copy_clipboard)((glong) __builtin_offsetof(EelEditableLabelClass, copy_clipboard
)),

282

NULL((void*)0), NULL((void*)0),

283

g_cclosure_marshal_VOID__VOID,

284

G_TYPE_NONE((GType) ((1) << (2))), 0);

285

286

signals[POPULATE_POPUP] =

287

g_signal_new ("populate_popup",

288

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

289

G_SIGNAL_RUN_LAST,

290

G_STRUCT_OFFSET (EelEditableLabelClass, populate_popup)((glong) __builtin_offsetof(EelEditableLabelClass, populate_popup
)),

291

NULL((void*)0), NULL((void*)0),

292

g_cclosure_marshal_VOID__OBJECT,

293

G_TYPE_NONE((GType) ((1) << (2))), 1, CTK_TYPE_MENU(ctk_menu_get_type ()));

294

295

signals[DELETE_FROM_CURSOR] =

296

g_signal_new ("delete_from_cursor",

297

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

298

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

299

G_STRUCT_OFFSET (EelEditableLabelClass, delete_from_cursor)((glong) __builtin_offsetof(EelEditableLabelClass, delete_from_cursor
)),

300

NULL((void*)0), NULL((void*)0),

301

eel_marshal_VOID__ENUM_INT,

302

G_TYPE_NONE((GType) ((1) << (2))), 2, CTK_TYPE_DELETE_TYPE(ctk_delete_type_get_type ()), G_TYPE_INT((GType) ((6) << (2))));

303

304

signals[CUT_CLIPBOARD] =

305

g_signal_new ("cut_clipboard",

306

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

307

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

308

G_STRUCT_OFFSET (EelEditableLabelClass, cut_clipboard)((glong) __builtin_offsetof(EelEditableLabelClass, cut_clipboard
)),

309

NULL((void*)0), NULL((void*)0),

310

g_cclosure_marshal_VOID__VOID,

311

G_TYPE_NONE((GType) ((1) << (2))), 0);

312

313

signals[PASTE_CLIPBOARD] =

314

g_signal_new ("paste_clipboard",

315

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

316

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

317

G_STRUCT_OFFSET (EelEditableLabelClass, paste_clipboard)((glong) __builtin_offsetof(EelEditableLabelClass, paste_clipboard
)),

318

NULL((void*)0), NULL((void*)0),

319

g_cclosure_marshal_VOID__VOID,

320

G_TYPE_NONE((GType) ((1) << (2))), 0);

321

322

signals[TOGGLE_OVERWRITE] =

323

g_signal_new ("toggle_overwrite",

324

G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type),

325

G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

326

G_STRUCT_OFFSET (EelEditableLabelClass, toggle_overwrite)((glong) __builtin_offsetof(EelEditableLabelClass, toggle_overwrite
)),

327

NULL((void*)0), NULL((void*)0),

328

g_cclosure_marshal_VOID__VOID,

329

G_TYPE_NONE((GType) ((1) << (2))), 0);

330

331

332

g_object_class_install_property (gobject_class,

333

PROP_TEXT,

334

g_param_spec_string ("text",

335

_("Text")((char *) g_dgettext ("baul", "Text")),

336

_("The text of the label.")((char *) g_dgettext ("baul", "The text of the label.")),

337

NULL((void*)0),

338

G_PARAM_READWRITE));

339

g_object_class_install_property (gobject_class,

340

PROP_JUSTIFY,

341

g_param_spec_enum ("justify",

342

_("Justification")((char *) g_dgettext ("baul", "Justification")),

343

_("The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See CtkMisc::xalign for that.")((char *) g_dgettext ("baul", "The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See CtkMisc::xalign for that."
)),

344

CTK_TYPE_JUSTIFICATION(ctk_justification_get_type ()),

345

CTK_JUSTIFY_LEFT,

346

G_PARAM_READWRITE));

347

348

g_object_class_install_property (gobject_class,

349

PROP_WRAP,

350

g_param_spec_boolean ("wrap",

351

_("Line wrap")((char *) g_dgettext ("baul", "Line wrap")),

352

_("If set, wrap lines if the text becomes too wide.")((char *) g_dgettext ("baul", "If set, wrap lines if the text becomes too wide."
)),

353

FALSE(0),

354

G_PARAM_READWRITE));

355

356

g_object_class_install_property (gobject_class,

357

PROP_CURSOR_POSITION,

358

g_param_spec_int ("cursor_position",

359

_("Cursor Position")((char *) g_dgettext ("baul", "Cursor Position")),

360

_("The current position of the insertion cursor in chars.")((char *) g_dgettext ("baul", "The current position of the insertion cursor in chars."
)),

361

0,

362

G_MAXINT2147483647,

363

0,

364

G_PARAM_READABLE));

365

366

g_object_class_install_property (gobject_class,

367

PROP_SELECTION_BOUND,

368

g_param_spec_int ("selection_bound",

369

_("Selection Bound")((char *) g_dgettext ("baul", "Selection Bound")),

370

_("The position of the opposite end of the selection from the cursor in chars.")((char *) g_dgettext ("baul", "The position of the opposite end of the selection from the cursor in chars."
)),

371

0,

372

G_MAXINT2147483647,

373

0,

374

G_PARAM_READABLE));

375

376

/*

377

* Key bindings

378

*/

379

380

binding_set = ctk_binding_set_by_class (class);

381

382

/* Moving the insertion point */

383

add_move_binding (binding_set, CDK_KEY_Right0xff53, 0,

384

CTK_MOVEMENT_VISUAL_POSITIONS, 1);

385

386

add_move_binding (binding_set, CDK_KEY_Left0xff51, 0,

387

CTK_MOVEMENT_VISUAL_POSITIONS, -1);

388

389

add_move_binding (binding_set, CDK_KEY_KP_Right0xff98, 0,

390

CTK_MOVEMENT_VISUAL_POSITIONS, 1);

391

392

add_move_binding (binding_set, CDK_KEY_KP_Left0xff96, 0,

393

CTK_MOVEMENT_VISUAL_POSITIONS, -1);

394

395

add_move_binding (binding_set, CDK_KEY_f0x066, CDK_CONTROL_MASK,

396

CTK_MOVEMENT_LOGICAL_POSITIONS, 1);

397

398

add_move_binding (binding_set, CDK_KEY_b0x062, CDK_CONTROL_MASK,

399

CTK_MOVEMENT_LOGICAL_POSITIONS, -1);

400

401

add_move_binding (binding_set, CDK_KEY_Right0xff53, CDK_CONTROL_MASK,

402

CTK_MOVEMENT_WORDS, 1);

403

404

add_move_binding (binding_set, CDK_KEY_Left0xff51, CDK_CONTROL_MASK,

405

CTK_MOVEMENT_WORDS, -1);

406

407

add_move_binding (binding_set, CDK_KEY_KP_Right0xff98, CDK_CONTROL_MASK,

408

CTK_MOVEMENT_WORDS, 1);

409

410

add_move_binding (binding_set, CDK_KEY_KP_Left0xff96, CDK_CONTROL_MASK,

411

CTK_MOVEMENT_WORDS, -1);

412

413

add_move_binding (binding_set, CDK_KEY_a0x061, CDK_CONTROL_MASK,

414

CTK_MOVEMENT_PARAGRAPH_ENDS, -1);

415

416

add_move_binding (binding_set, CDK_KEY_e0x065, CDK_CONTROL_MASK,

417

CTK_MOVEMENT_PARAGRAPH_ENDS, 1);

418

419

add_move_binding (binding_set, CDK_KEY_f0x066, CDK_MOD1_MASK,

420

CTK_MOVEMENT_WORDS, 1);

421

422

add_move_binding (binding_set, CDK_KEY_b0x062, CDK_MOD1_MASK,

423

CTK_MOVEMENT_WORDS, -1);

424

425

add_move_binding (binding_set, CDK_KEY_Home0xff50, 0,

426

CTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);

427

428

add_move_binding (binding_set, CDK_KEY_End0xff57, 0,

429

CTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);

430

431

add_move_binding (binding_set, CDK_KEY_KP_Home0xff95, 0,

432

CTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);

433

434

add_move_binding (binding_set, CDK_KEY_KP_End0xff9c, 0,

435

CTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);

436

437

add_move_binding (binding_set, CDK_KEY_Home0xff50, CDK_CONTROL_MASK,

438

CTK_MOVEMENT_BUFFER_ENDS, -1);

439

440

add_move_binding (binding_set, CDK_KEY_End0xff57, CDK_CONTROL_MASK,

441

CTK_MOVEMENT_BUFFER_ENDS, 1);

442

443

add_move_binding (binding_set, CDK_KEY_KP_Home0xff95, CDK_CONTROL_MASK,

444

CTK_MOVEMENT_BUFFER_ENDS, -1);

445

446

add_move_binding (binding_set, CDK_KEY_KP_End0xff9c, CDK_CONTROL_MASK,

447

CTK_MOVEMENT_BUFFER_ENDS, 1);

448

449

add_move_binding (binding_set, CDK_KEY_Up0xff52, 0,

450

CTK_MOVEMENT_DISPLAY_LINES, -1);

451

452

add_move_binding (binding_set, CDK_KEY_KP_Up0xff97, 0,

453

CTK_MOVEMENT_DISPLAY_LINES, -1);

454

455

add_move_binding (binding_set, CDK_KEY_Down0xff54, 0,

456

CTK_MOVEMENT_DISPLAY_LINES, 1);

457

458

add_move_binding (binding_set, CDK_KEY_KP_Down0xff99, 0,

459

CTK_MOVEMENT_DISPLAY_LINES, 1);

460

461

/* Select all

462

*/

463

ctk_binding_entry_add_signal (binding_set, CDK_KEY_a0x061, CDK_CONTROL_MASK,

464

"move_cursor", 3,

465

CTK_TYPE_MOVEMENT_STEP(ctk_movement_step_get_type ()), CTK_MOVEMENT_BUFFER_ENDS,

466

G_TYPE_INT((GType) ((6) << (2))), -1,

467

G_TYPE_BOOLEAN((GType) ((5) << (2))), FALSE(0));

468

ctk_binding_entry_add_signal (binding_set, CDK_KEY_a0x061, CDK_CONTROL_MASK,

469

"move_cursor", 3,

470

CTK_TYPE_MOVEMENT_STEP(ctk_movement_step_get_type ()), CTK_MOVEMENT_BUFFER_ENDS,

471

G_TYPE_INT((GType) ((6) << (2))), 1,

472

G_TYPE_BOOLEAN((GType) ((5) << (2))), TRUE(!(0)));

473

474

/* Deleting text */

475

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Delete0xffff, 0,

476

"delete_from_cursor", 2,

477

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_CHARS,

478

G_TYPE_INT((GType) ((6) << (2))), 1);

479

480

ctk_binding_entry_add_signal (binding_set, CDK_KEY_KP_Delete0xff9f, 0,

481

"delete_from_cursor", 2,

482

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_CHARS,

483

G_TYPE_INT((GType) ((6) << (2))), 1);

484

485

ctk_binding_entry_add_signal (binding_set, CDK_KEY_BackSpace0xff08, 0,

486

"delete_from_cursor", 2,

487

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_CHARS,

488

G_TYPE_INT((GType) ((6) << (2))), -1);

489

490

/* Make this do the same as Backspace, to help with mis-typing */

491

ctk_binding_entry_add_signal (binding_set, CDK_KEY_BackSpace0xff08, CDK_SHIFT_MASK,

492

"delete_from_cursor", 2,

493

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_CHARS,

494

G_TYPE_INT((GType) ((6) << (2))), -1);

495

496

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Delete0xffff, CDK_CONTROL_MASK,

497

"delete_from_cursor", 2,

498

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_WORD_ENDS,

499

G_TYPE_INT((GType) ((6) << (2))), 1);

500

501

ctk_binding_entry_add_signal (binding_set, CDK_KEY_KP_Delete0xff9f, CDK_CONTROL_MASK,

502

"delete_from_cursor", 2,

503

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_WORD_ENDS,

504

G_TYPE_INT((GType) ((6) << (2))), 1);

505

506

ctk_binding_entry_add_signal (binding_set, CDK_KEY_BackSpace0xff08, CDK_CONTROL_MASK,

507

"delete_from_cursor", 2,

508

G_TYPE_ENUM((GType) ((12) << (2))), CTK_DELETE_WORD_ENDS,

509

G_TYPE_INT((GType) ((6) << (2))), -1);

510

511

/* Cut/copy/paste */

512

513

ctk_binding_entry_add_signal (binding_set, CDK_KEY_x0x078, CDK_CONTROL_MASK,

514

"cut_clipboard", 0);

515

ctk_binding_entry_add_signal (binding_set, CDK_KEY_c0x063, CDK_CONTROL_MASK,

516

"copy_clipboard", 0);

517

ctk_binding_entry_add_signal (binding_set, CDK_KEY_v0x076, CDK_CONTROL_MASK,

518

"paste_clipboard", 0);

519

520

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Delete0xffff, CDK_SHIFT_MASK,

521

"cut_clipboard", 0);

522

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Insert0xff63, CDK_CONTROL_MASK,

523

"copy_clipboard", 0);

524

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Insert0xff63, CDK_SHIFT_MASK,

525

"paste_clipboard", 0);

526

527

/* Overwrite */

528

ctk_binding_entry_add_signal (binding_set, CDK_KEY_Insert0xff63, 0,

529

"toggle_overwrite", 0);

530

ctk_binding_entry_add_signal (binding_set, CDK_KEY_KP_Insert0xff9e, 0,

531

"toggle_overwrite", 0);

532

}

533

534

static void

535

eel_editable_label_editable_init (CtkEditableInterface *iface)

536

{

537

iface->do_insert_text = editable_insert_text_emit;

538

iface->do_delete_text = editable_delete_text_emit;

539

iface->insert_text = editable_insert_text;

540

iface->delete_text = editable_delete_text;

541

iface->get_chars = editable_get_chars;

542

iface->set_selection_bounds = editable_set_selection_bounds;

543

iface->get_selection_bounds = editable_get_selection_bounds;

544

iface->set_position = editable_real_set_position;

545

iface->get_position = editable_get_position;

546

}

547

548

549

static void

550

eel_editable_label_set_property (GObject *object,

551

guint prop_id,

552

const GValue *value,

553

GParamSpec *pspec)

554

{

555

EelEditableLabel *label;

556

557

label = EEL_EDITABLE_LABEL (object)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((object)), (eel_editable_label_get_type())))
));

558

559

switch (prop_id)

560

{

561

case PROP_TEXT:

562

eel_editable_label_set_text (label, g_value_get_string (value));

563

break;

564

case PROP_JUSTIFY:

565

eel_editable_label_set_justify (label, g_value_get_enum (value));

566

break;

567

case PROP_WRAP:

568

eel_editable_label_set_line_wrap (label, g_value_get_boolean (value));

569

break;

570

default:

571

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
*_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
= ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "eel-editable-label.c", 571, ("property"), _glib__property_id
, _glib__pspec->name, g_type_name ((((((GTypeClass*) (((GTypeInstance
*) (_glib__pspec))->g_class))->g_type)))), (g_type_name
((((((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);

572

break;

573

}

574

}

575

576

static void

577

eel_editable_label_get_property (GObject *object,

578

guint prop_id,

579

GValue *value,

580

GParamSpec *pspec)

581

{

582

EelEditableLabel *label;

583

gint offset;

584

585

label = EEL_EDITABLE_LABEL (object)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((object)), (eel_editable_label_get_type())))
));

586

587

switch (prop_id)

588

{

589

case PROP_TEXT:

590

g_value_set_string (value, label->text);

591

break;

592

case PROP_JUSTIFY:

593

g_value_set_enum (value, label->jtype);

594

break;

595

case PROP_WRAP:

596

g_value_set_boolean (value, label->wrap);

597

break;

598

case PROP_CURSOR_POSITION:

599

offset = g_utf8_pointer_to_offset (label->text,

600

label->text + label->selection_end);

601

g_value_set_int (value, offset);

602

break;

603

case PROP_SELECTION_BOUND:

604

offset = g_utf8_pointer_to_offset (label->text,

605

label->text + label->selection_anchor);

606

g_value_set_int (value, offset);

607

break;

608

609

default:

610

G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
*_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
= ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "eel-editable-label.c", 610, ("property"), _glib__property_id
, _glib__pspec->name, g_type_name ((((((GTypeClass*) (((GTypeInstance
*) (_glib__pspec))->g_class))->g_type)))), (g_type_name
((((((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);

611

break;

612

}

613

}

614

615

static void

616

eel_editable_label_init (EelEditableLabel *label)

617

{

618

label->jtype = CTK_JUSTIFY_LEFT;

619

label->wrap = FALSE(0);

620

label->wrap_mode = PANGO_WRAP_WORD;

621

622

label->layout = NULL((void*)0);

623

label->text_size = 1;

624

label->text = g_malloc (label->text_size);

625

label->text[0] = '\0';

626

label->n_bytes = 0;

627

628

ctk_widget_set_can_focus (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))), TRUE(!(0)));

629

630

ctk_style_context_add_class (ctk_widget_get_style_context (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))),

631

CTK_STYLE_CLASS_ENTRY"entry");

632

633

/* This object is completely private. No external entity can gain a reference

634

* to it; so we create it here and destroy it in finalize().

635

*/

636

label->im_context = ctk_im_multicontext_new ();

637

638

g_signal_connect (G_OBJECT (label->im_context), "commit",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("commit"), (((GCallback) (eel_editable_label_commit_cb
))), (label), ((void*)0), (GConnectFlags) 0)

639

G_CALLBACK (eel_editable_label_commit_cb), label)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("commit"), (((GCallback) (eel_editable_label_commit_cb
))), (label), ((void*)0), (GConnectFlags) 0);

640

g_signal_connect (G_OBJECT (label->im_context), "preedit_changed",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("preedit_changed"), (((GCallback) (eel_editable_label_preedit_changed_cb
))), (label), ((void*)0), (GConnectFlags) 0)

641

G_CALLBACK (eel_editable_label_preedit_changed_cb), label)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("preedit_changed"), (((GCallback) (eel_editable_label_preedit_changed_cb
))), (label), ((void*)0), (GConnectFlags) 0);

642

g_signal_connect (G_OBJECT (label->im_context), "retrieve_surrounding",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("retrieve_surrounding"), (((GCallback) (eel_editable_label_retrieve_surrounding_cb
))), (label), ((void*)0), (GConnectFlags) 0)

643

G_CALLBACK (eel_editable_label_retrieve_surrounding_cb), label)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("retrieve_surrounding"), (((GCallback) (eel_editable_label_retrieve_surrounding_cb
))), (label), ((void*)0), (GConnectFlags) 0);

644

g_signal_connect (G_OBJECT (label->im_context), "delete_surrounding",g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("delete_surrounding"), (((GCallback) (eel_editable_label_delete_surrounding_cb
))), (label), ((void*)0), (GConnectFlags) 0)

645

G_CALLBACK (eel_editable_label_delete_surrounding_cb), label)g_signal_connect_data ((((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label->im_context)), (((GType) ((20) <<
(2))))))))), ("delete_surrounding"), (((GCallback) (eel_editable_label_delete_surrounding_cb
))), (label), ((void*)0), (GConnectFlags) 0);

646

}

647

648

/**

649

* eel_editable_label_new:

650

* @str: The text of the label

651

*

652

* Creates a new label with the given text inside it. You can

653

* pass %NULL to get an empty label widget.

654

*

655

* Return value: the new #EelEditableLabel

656

**/

657

CtkWidget*

658

eel_editable_label_new (const gchar *str)

659

{

660

EelEditableLabel *label;

661

662

label = g_object_new (EEL_TYPE_EDITABLE_LABELeel_editable_label_get_type(), NULL((void*)0));

663

664

if (str && *str)

665

eel_editable_label_set_text (label, str);

666

667

return CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))));

668

}

669

670

/**

671

* eel_editable_label_set_text:

672

* @label: a #EelEditableLabel

673

* @str: The text you want to set.

674

*

675

* Sets the text within the #EelEditableLabel widget. It overwrites any text that

676

* was there before.

677

*

678

* This will also clear any previously set mnemonic accelerators.

679

**/

680

void

681

eel_editable_label_set_text (EelEditableLabel *label,

682

const gchar *str)

683

{

684

CtkEditable *editable;

685

int tmp_pos;

686

687

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

688

g_return_if_fail (str != NULL)do { if ((str != ((void*)0))) { } else { g_return_if_fail_warning
("Eel", ((const char*) (__func__)), "str != NULL"); return; }
} while (0);

689

690

if (strcmp (label->text, str) == 0)

691

return;

692

693

editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

694

ctk_editable_delete_text (editable, 0, -1);

695

tmp_pos = 0;

696

ctk_editable_insert_text (editable, str, strlen (str), &tmp_pos);

697

}

698

699

/**

700

* eel_editable_label_get_text:

701

* @label: a #EelEditableLabel

702

*

703

* Fetches the text from a label widget, as displayed on the

704

* screen. This does not include any embedded underlines

705

* indicating mnemonics or Pango markup. (See eel_editable_label_get_label())

706

*

707

* Return value: the text in the label widget. This is the internal

708

* string used by the label, and must not be modified.

709

**/

710

const gchar* eel_editable_label_get_text(EelEditableLabel* label)

711

{

712

g_return_val_if_fail(EEL_IS_EDITABLE_LABEL(label), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL(label)"); return (((void*)0)); } }
while (0);

713

714

return label->text;

715

}

716

717

/**

718

* eel_editable_label_set_justify:

719

* @label: a #EelEditableLabel

720

* @jtype: a #CtkJustification

721

*

722

* Sets the alignment of the lines in the text of the label relative to

723

* each other. %CTK_JUSTIFY_LEFT is the default value when the

724

* widget is first created with eel_editable_label_new(). If you instead want

725

* to set the alignment of the label as a whole, use

726

* ctk_misc_set_alignment() instead. eel_editable_label_set_justify() has no

727

* effect on labels containing only a single line.

728

**/

729

void

730

eel_editable_label_set_justify (EelEditableLabel *label,

731

CtkJustification jtype)

732

{

733

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

734

g_return_if_fail (jtype >= CTK_JUSTIFY_LEFT && jtype <= CTK_JUSTIFY_FILL)do { if ((jtype >= CTK_JUSTIFY_LEFT && jtype <=
CTK_JUSTIFY_FILL)) { } else { g_return_if_fail_warning ("Eel"
, ((const char*) (__func__)), "jtype >= CTK_JUSTIFY_LEFT && jtype <= CTK_JUSTIFY_FILL"
); return; } } while (0);

735

736

if ((CtkJustification) label->jtype != jtype)

737

{

738

label->jtype = jtype;

739

740

/* No real need to be this drastic, but easier than duplicating the code */

741

eel_editable_label_recompute (label);

742

743

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "justify");

744

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

745

}

746

}

747

748

/**

749

* eel_editable_label_get_justify:

750

* @label: a #EelEditableLabel

751

*

752

* Returns the justification of the label. See eel_editable_label_set_justify ().

753

*

754

* Return value: #CtkJustification

755

**/

756

CtkJustification

757

eel_editable_label_get_justify (EelEditableLabel *label)

758

{

759

g_return_val_if_fail (EEL_IS_EDITABLE_LABEL (label), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return (0); } } while (
0);

760

761

return label->jtype;

762

}

763

764

void

765

eel_editable_label_set_draw_outline (EelEditableLabel *label,

766

gboolean draw_outline)

767

{

768

draw_outline = draw_outline != FALSE(0);

769

770

if (label->draw_outline != draw_outline)

771

{

772

label->draw_outline = draw_outline;

773

774

ctk_widget_queue_draw (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

775

}

776

777

}

778

779

780

/**

781

* eel_editable_label_set_line_wrap:

782

* @label: a #EelEditableLabel

783

* @wrap: the setting

784

*

785

* Toggles line wrapping within the #EelEditableLabel widget. %TRUE makes it break

786

* lines if text exceeds the widget's size. %FALSE lets the text get cut off

787

* by the edge of the widget if it exceeds the widget size.

788

**/

789

void

790

eel_editable_label_set_line_wrap (EelEditableLabel *label,

791

gboolean wrap)

792

{

793

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

794

795

wrap = wrap != FALSE(0);

796

797

if (label->wrap != wrap)

798

{

799

label->wrap = wrap;

800

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "wrap");

801

802

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

803

}

804

}

805

806

807

void

808

eel_editable_label_set_line_wrap_mode (EelEditableLabel *label,

809

PangoWrapMode mode)

810

{

811

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

812

813

if (label->wrap_mode != mode)

814

{

815

label->wrap_mode = mode;

816

817

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

818

}

819

820

}

821

822

823

/**

824

* eel_editable_label_get_line_wrap:

825

* @label: a #EelEditableLabel

826

*

827

* Returns whether lines in the label are automatically wrapped. See eel_editable_label_set_line_wrap ().

828

*

829

* Return value: %TRUE if the lines of the label are automatically wrapped.

830

*/

831

gboolean

832

eel_editable_label_get_line_wrap (EelEditableLabel *label)

833

{

834

g_return_val_if_fail (EEL_IS_EDITABLE_LABEL (label), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return ((0)); } } while
(0);

835

836

return label->wrap;

837

}

838

839

PangoFontDescription *

840

eel_editable_label_get_font_description (EelEditableLabel *label)

841

{

842

if (label->font_desc)

843

return pango_font_description_copy (label->font_desc);

844

845

return NULL((void*)0);

846

}

847

848

void

849

eel_editable_label_set_font_description (EelEditableLabel *label,

850

const PangoFontDescription *desc)

851

{

852

if (label->font_desc)

853

pango_font_description_free (label->font_desc);

854

855

if (desc)

856

label->font_desc = pango_font_description_copy (desc);

857

else

858

label->font_desc = NULL((void*)0);

859

860

eel_editable_label_clear_layout (label);

861

}

862

863

static void

864

eel_editable_label_finalize (GObject *object)

865

{

866

EelEditableLabel *label;

867

868

g_assert (EEL_IS_EDITABLE_LABEL (object))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((object)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 868
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL (object)"
); } while (0);

869

870

label = EEL_EDITABLE_LABEL (object)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((object)), (eel_editable_label_get_type())))
));

871

872

if (label->font_desc)

873

{

874

pango_font_description_free (label->font_desc);

875

label->font_desc = NULL((void*)0);

876

}

877

878

g_object_unref (G_OBJECT (label->im_context)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->im_context)), (((GType) ((20) << (2)))))
))));

879

label->im_context = NULL((void*)0);

880

881

g_free (label->text);

882

label->text = NULL((void*)0);

883

884

if (label->layout)

885

{

886

g_object_unref (G_OBJECT (label->layout)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->layout)), (((GType) ((20) << (2)))))))));

887

label->layout = NULL((void*)0);

888

}

889

890

G_OBJECT_CLASS (eel_editable_label_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), (((GType) ((20) <<
(2))))))))->finalize (object);

891

}

892

893

static void

894

eel_editable_label_clear_layout (EelEditableLabel *label)

895

{

896

if (label->layout)

897

{

898

g_object_unref (G_OBJECT (label->layout)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->layout)), (((GType) ((20) << (2)))))))));

899

label->layout = NULL((void*)0);

900

}

901

}

902

903

static void

904

eel_editable_label_recompute (EelEditableLabel *label)

905

{

906

eel_editable_label_clear_layout (label);

907

eel_editable_label_check_cursor_blink (label);

908

}

909

910

typedef struct _LabelWrapWidth LabelWrapWidth;

911

struct _LabelWrapWidth

912

{

913

gint width;

914

PangoFontDescription *font_desc;

915

};

916

917

static void

918

label_wrap_width_free (gpointer data)

919

{

920

LabelWrapWidth *wrap_width = data;

921

pango_font_description_free (wrap_width->font_desc);

922

g_free (wrap_width);

923

}

924

925

static gint

926

get_label_wrap_width (EelEditableLabel *label)

927

{

928

PangoLayout *layout;

929

CtkStyleContext *style = ctk_widget_get_style_context (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

930

PangoFontDescription *desc;

931

932

LabelWrapWidth *wrap_width = g_object_get_data (G_OBJECT (style)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((style)), (((GType) ((20) << (2)))))))), "ctk-label-wrap-width");

933

if (!wrap_width)

934

{

935

wrap_width = g_new0 (LabelWrapWidth, 1)((LabelWrapWidth *) g_malloc0_n ((1), sizeof (LabelWrapWidth)
));

936

g_object_set_data_full (G_OBJECT (style)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((style)), (((GType) ((20) << (2)))))))), "ctk-label-wrap-width",

937

wrap_width, label_wrap_width_free);

938

}

939

940

ctk_style_context_get (style, ctk_widget_get_state_flags (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))),

941

CTK_STYLE_PROPERTY_FONT"font", &desc,

942

NULL((void*)0));

943

944

if (wrap_width->font_desc && pango_font_description_equal (wrap_width->font_desc, desc))

945

goto out;

946

947

if (wrap_width->font_desc)

948

pango_font_description_free (wrap_width->font_desc);

949

950

wrap_width->font_desc = pango_font_description_copy (desc);

951

952

layout = ctk_widget_create_pango_layout (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))),

953

"This long string gives a good enough length for any line to have.");

954

pango_layout_get_size (layout, &wrap_width->width, NULL((void*)0));

955

g_object_unref (layout);

956

957

out:

958

pango_font_description_free (desc);

959

return wrap_width->width;

960

}

961

962

static void

963

eel_editable_label_ensure_layout (EelEditableLabel *label,

964

gboolean include_preedit)

965

{

966

CtkWidget *widget;

967

PangoRectangle logical_rect;

968

969

/* Normalize for comparisons */

970

include_preedit = include_preedit != 0;

971

972

if (label->preedit_length > 0 &&

973

include_preedit != label->layout_includes_preedit)

974

eel_editable_label_clear_layout (label);

975

976

widget = CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))));

977

978

if (label->layout == NULL((void*)0))

979

{

980

gchar *preedit_string = NULL((void*)0);

981

gint preedit_length = 0;

982

PangoAttrList *preedit_attrs = NULL((void*)0);

983

PangoAlignment align = PANGO_ALIGN_LEFT; /* Quiet gcc */

984

PangoAttrList *tmp_attrs = pango_attr_list_new ();

985

986

if (include_preedit)

987

{

988

ctk_im_context_get_preedit_string (label->im_context,

989

&preedit_string, &preedit_attrs, NULL((void*)0));

990

preedit_length = label->preedit_length;

991

}

992

993

if (preedit_length)

994

{

995

GString *tmp_string = g_string_new (NULL((void*)0));

996

997

g_string_prepend_len (tmp_string, label->text, label->n_bytes);

998

g_string_insert (tmp_string, label->selection_anchor, preedit_string);

999

1000

label->layout = ctk_widget_create_pango_layout (widget, tmp_string->str);

1001

1002

pango_attr_list_splice (tmp_attrs, preedit_attrs,

1003

label->selection_anchor, preedit_length);

1004

1005

g_string_free (tmp_string, TRUE)(__builtin_constant_p ((!(0))) ? (((!(0))) ? (g_string_free) (
(tmp_string), ((!(0)))) : g_string_free_and_steal (tmp_string
)) : (g_string_free) ((tmp_string), ((!(0)))));

1006

}

1007

else

1008

{

1009

label->layout = ctk_widget_create_pango_layout (widget, label->text);

1010

}

1011

label->layout_includes_preedit = include_preedit;

1012

1013

if (label->font_desc != NULL((void*)0))

1014

pango_layout_set_font_description (label->layout, label->font_desc);

1015

1016

#if PANGO_CHECK_VERSION (1, 44, 0)(1 > (1) || (1 == (1) && 58 > (44)) || (1 == (1
) && 58 == (44) && 0 >= (0)))

1017

pango_attr_list_insert (tmp_attrs, pango_attr_insert_hyphens_new (FALSE(0)));

1018

#endif

1019

pango_layout_set_attributes (label->layout, tmp_attrs);

1020

1021

if (preedit_string)

1022

g_free (preedit_string);

1023

if (preedit_attrs)

1024

pango_attr_list_unref (preedit_attrs);

1025

pango_attr_list_unref (tmp_attrs);

1026

1027

switch (label->jtype)

1028

{

1029

case CTK_JUSTIFY_LEFT:

1030

align = PANGO_ALIGN_LEFT;

1031

break;

1032

case CTK_JUSTIFY_RIGHT:

1033

align = PANGO_ALIGN_RIGHT;

1034

break;

1035

case CTK_JUSTIFY_CENTER:

1036

align = PANGO_ALIGN_CENTER;

1037

break;

1038

case CTK_JUSTIFY_FILL:

1039

/* FIXME: This just doesn't work to do this */

1040

align = PANGO_ALIGN_LEFT;

1041

pango_layout_set_justify (label->layout, TRUE(!(0)));

1042

break;

1043

default:

1044

g_assert_not_reached()do { g_assertion_message_expr ("Eel", "eel-editable-label.c",
1044, ((const char*) (__func__)), ((void*)0)); } while (0);

1045

}

1046

1047

pango_layout_set_alignment (label->layout, align);

1048

1049

if (label->wrap)

1050

{

1051

gint longest_paragraph;

1052

gint width, height;

1053

gint set_width;

1054

1055

ctk_widget_get_size_request (widget, &set_width, NULL((void*)0));

1056

if (set_width > 0)

1057

pango_layout_set_width (label->layout, set_width * PANGO_SCALE1024);

1058

else

1059

{

1060

gint wrap_width;

1061

gint scale;

1062

1063

pango_layout_set_width (label->layout, -1);

1064

pango_layout_get_extents (label->layout, NULL((void*)0), &logical_rect);

1065

1066

width = logical_rect.width;

1067

1068

/* Try to guess a reasonable maximum width */

1069

longest_paragraph = width;

1070

1071

wrap_width = get_label_wrap_width (label);

1072

scale = ctk_widget_get_scale_factor (widget);

1073

width = MIN (width, wrap_width)(((width) < (wrap_width)) ? (width) : (wrap_width));

1074

width = MIN (width,(((width) < (1024 * (((cdk_x11_screen_get_xscreen (cdk_screen_get_default
()))->width) / scale + 1) / 2)) ? (width) : (1024 * (((cdk_x11_screen_get_xscreen
(cdk_screen_get_default ()))->width) / scale + 1) / 2))

1075

PANGO_SCALE * (WidthOfScreen (cdk_x11_screen_get_xscreen (cdk_screen_get_default ())) / scale + 1) / 2)(((width) < (1024 * (((cdk_x11_screen_get_xscreen (cdk_screen_get_default
()))->width) / scale + 1) / 2)) ? (width) : (1024 * (((cdk_x11_screen_get_xscreen
(cdk_screen_get_default ()))->width) / scale + 1) / 2));

1076

1077

pango_layout_set_width (label->layout, width);

1078

pango_layout_get_extents (label->layout, NULL((void*)0), &logical_rect);

1079

width = logical_rect.width;

1080

height = logical_rect.height;

1081

1082

/* Unfortunately, the above may leave us with a very unbalanced looking paragraph,

1083

* so we try short search for a narrower width that leaves us with the same height

1084

*/

1085

if (longest_paragraph > 0)

1086

{

1087

gint nlines, perfect_width;

1088

1089

nlines = pango_layout_get_line_count (label->layout);

1090

perfect_width = (longest_paragraph + nlines - 1) / nlines;

1091

1092

if (perfect_width < width)

1093

{

1094

pango_layout_set_width (label->layout, perfect_width);

1095

pango_layout_get_extents (label->layout, NULL((void*)0), &logical_rect);

1096

1097

if (logical_rect.height <= height)

1098

width = logical_rect.width;

1099

else

1100

{

1101

gint mid_width = (perfect_width + width) / 2;

1102

1103

if (mid_width > perfect_width)

1104

{

1105

pango_layout_set_width (label->layout, mid_width);

1106

pango_layout_get_extents (label->layout, NULL((void*)0), &logical_rect);

1107

1108

if (logical_rect.height <= height)

1109

width = logical_rect.width;

1110

}

1111

}

1112

}

1113

}

1114

pango_layout_set_width (label->layout, width);

1115

}

1116

pango_layout_set_wrap (label->layout, label->wrap_mode);

1117

}

1118

else /* !label->wrap */

1119

pango_layout_set_width (label->layout, -1);

1120

}

1121

}

1122

1123

static void

1124

eel_editable_label_size_request (CtkWidget *widget,

1125

CtkRequisition *requisition)

1126

{

1127

EelEditableLabel *label;

1128

gint width, height;

1129

PangoRectangle logical_rect;

1130

gint set_width;

1131

gint xpad, ypad;

1132

gint margin_start, margin_end, margin_top, margin_bottom;

1133

1134

1135

g_assert (EEL_IS_EDITABLE_LABEL (widget))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((widget)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 1135
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL (widget)"
); } while (0);

1136

g_assert (requisition != NULL)do { if (requisition != ((void*)0)) ; else g_assertion_message_expr
("Eel", "eel-editable-label.c", 1136, ((const char*) (__func__
)), "requisition != NULL"); } while (0);

1137

1138

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1139

1140

/*

1141

* If word wrapping is on, then the height requisition can depend

1142

* on:

1143

*

1144

* - Any width set on the widget via ctk_widget_set_size_request().

1145

* - The padding of the widget (xpad, set by ctk_misc_set_padding)

1146

*

1147

* Instead of trying to detect changes to these quantities, if we

1148

* are wrapping, we just rewrap for each size request. Since

1149

* size requisitions are cached by the CTK+ core, this is not

1150

* expensive.

1151

*/

1152

1153

if (label->wrap)

1154

eel_editable_label_recompute (label);

1155

1156

eel_editable_label_ensure_layout (label, TRUE(!(0)));

1157

1158

margin_start = ctk_widget_get_margin_start (widget);

1159

margin_end = ctk_widget_get_margin_end (widget);

1160

margin_top = ctk_widget_get_margin_top (widget);

1161

margin_bottom = ctk_widget_get_margin_bottom (widget);

1162

1163

xpad = margin_start + margin_end;

1164

ypad = margin_top + margin_bottom;

1165

width = xpad * 2;

1166

height = ypad * 2;

1167

1168

pango_layout_get_extents (label->layout, NULL((void*)0), &logical_rect);

1169

1170

ctk_widget_get_size_request (widget, &set_width, NULL((void*)0));

1171

if (label->wrap && set_width > 0)

1172

width += set_width;

1173

else

1174

width += PANGO_PIXELS (logical_rect.width)(((int)(logical_rect.width) + 512) >> 10);

1175

1176

height += PANGO_PIXELS (logical_rect.height)(((int)(logical_rect.height) + 512) >> 10);

1177

1178

requisition->width = width;

1179

requisition->height = height;

1180

}

1181

1182

static void

1183

eel_editable_label_get_preferred_width (CtkWidget *widget,

1184

gint *minimum,

1185

gint *natural)

1186

{

1187

CtkRequisition requisition;

1188

1189

eel_editable_label_size_request (widget, &requisition);

1190

1191

*minimum = *natural = requisition.width;

1192

}

1193

1194

static void

1195

eel_editable_label_get_preferred_height (CtkWidget *widget,

1196

gint *minimum,

1197

gint *natural)

1198

{

1199

CtkRequisition requisition;

1200

1201

eel_editable_label_size_request (widget, &requisition);

1202

1203

*minimum = *natural = requisition.height;

1204

}

1205

1206

static void

1207

eel_editable_label_size_allocate (CtkWidget *widget,

1208

CtkAllocation *allocation)

1209

{

1210

(* CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->size_allocate) (widget, allocation);

1211

}

1212

1213

static void

1214

eel_editable_label_state_changed (CtkWidget *widget,

1215

CtkStateType prev_state)

1216

{

1217

EelEditableLabel *label;

1218

1219

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1220

1221

/* clear any selection if we're insensitive */

1222

if (!ctk_widget_is_sensitive (widget))

1223

eel_editable_label_select_region (label, 0, 0);

1224

1225

if (CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->state_changed)

1226

CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->state_changed (widget, prev_state);

1227

}

1228

1229

static void

1230

eel_editable_label_style_updated (CtkWidget *widget)

1231

{

1232

EelEditableLabel *label;

1233

1234

g_assert (EEL_IS_EDITABLE_LABEL (widget))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((widget)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 1234
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL (widget)"
); } while (0);

1235

1236

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1237

1238

CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->style_updated (widget);

1239

1240

/* We have to clear the layout, fonts etc. may have changed */

1241

eel_editable_label_recompute (label);

1242

}

1243

1244

static void

1245

eel_editable_label_direction_changed (CtkWidget *widget,

1246

CtkTextDirection previous_dir)

1247

{

1248

EelEditableLabel *label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1249

1250

if (label->layout)

1251

pango_layout_context_changed (label->layout);

1252

1253

CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->direction_changed (widget, previous_dir);

1254

}

1255

1256

static gfloat

1257

ctk_align_to_gfloat (CtkAlign align)

1258

{

1259

switch (align) {

1260

case CTK_ALIGN_START:

1261

return 0.0;

1262

case CTK_ALIGN_END:

1263

return 1.0;

1264

case CTK_ALIGN_CENTER:

1265

case CTK_ALIGN_FILL:

1266

return 0.5;

1267

default:

1268

return 0.0;

1269

}

1270

}

1271

1272

static void

1273

get_layout_location (EelEditableLabel *label,

1274

gint *xp,

1275

gint *yp)

1276

{

1277

CtkWidget *widget;

1278

gfloat xalign, yalign;

1279

CtkRequisition req;

1280

gint x, y, xpad, ypad;

1281

gint margin_start, margin_end, margin_top, margin_bottom;

1282

CtkAllocation allocation;

1283

1284

widget = CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))));

1285

xalign = ctk_align_to_gfloat (ctk_widget_get_halign (widget));

1286

yalign = ctk_align_to_gfloat (ctk_widget_get_valign (widget));

1287

1288

if (ctk_widget_get_direction (widget) != CTK_TEXT_DIR_LTR)

1289

xalign = 1.0 - xalign;

1290

1291

ctk_widget_get_preferred_size (widget, &req, NULL((void*)0));

1292

margin_start = ctk_widget_get_margin_start (widget);

1293

margin_end = ctk_widget_get_margin_end (widget);

1294

margin_top = ctk_widget_get_margin_top (widget);

1295

margin_bottom = ctk_widget_get_margin_bottom (widget);

1296

1297

xpad = margin_start + margin_end;

1298

ypad = margin_top + margin_bottom;

1299

1300

ctk_widget_get_allocation (widget, &allocation);

1301

x = floor (0.5 + xpad

1302

+ ((allocation.width - req.width) * xalign)

1303

+ 0.5);

1304

1305

y = floor (0.5 + ypad

1306

+ ((allocation.height - req.height) * yalign)

1307

+ 0.5);

1308

1309

if (xp)

1310

*xp = x;

1311

1312

if (yp)

1313

*yp = y;

1314

}

1315

1316

static gint

1317

eel_editable_label_get_cursor_pos (EelEditableLabel *label,

1318

PangoRectangle *strong_pos,

1319

PangoRectangle *weak_pos)

1320

{

1321

const gchar *text;

1322

const gchar *preedit_text;

1323

gint index;

1324

1325

eel_editable_label_ensure_layout (label, TRUE(!(0)));

1326

1327

text = pango_layout_get_text (label->layout);

1328

preedit_text = text + label->selection_anchor;

1329

index = label->selection_anchor +

1330

g_utf8_offset_to_pointer (preedit_text, label->preedit_cursor) - preedit_text;

1331

1332

pango_layout_get_cursor_pos (label->layout, index, strong_pos, weak_pos);

1333

1334

return index;

1335

}

1336

1337

/* Copied from ctkutil private function */

1338

static gboolean

1339

eel_editable_label_get_block_cursor_location (EelEditableLabel *label,

1340

gint *index,

1341

PangoRectangle *pos,

1342

gboolean *at_line_end)

1343

{

1344

const gchar *text;

1345

const gchar *preedit_text;

1346

PangoLayoutLine *layout_line;

1347

PangoRectangle strong_pos, weak_pos;

1348

gint line_no;

1349

gboolean rtl;

1350

PangoContext *context;

1351

PangoFontMetrics *metrics;

1352

const PangoFontDescription *font_desc;

1353

1354

eel_editable_label_ensure_layout (label, TRUE(!(0)));

1355

1356

text = pango_layout_get_text (label->layout);

1357

preedit_text = text + label->selection_anchor;

1358

text = g_utf8_offset_to_pointer (preedit_text, label->preedit_cursor);

1359

index[0] = label->selection_anchor + text - preedit_text;

1360

1361

pango_layout_index_to_pos (label->layout, index[0], pos);

1362

1363

index[1] = label->selection_anchor + g_utf8_next_char (text)((text) + g_utf8_skip[*(const guchar *)(text)]) - preedit_text;

1364

1365

if (pos->width != 0)

1366

{

1367

if (at_line_end)

1368

*at_line_end = FALSE(0);

1369

if (pos->width < 0) /* RTL char, shift x value back to top left of rect */

1370

{

1371

pos->x += pos->width;

1372

pos->width = -pos->width;

1373

}

1374

return TRUE(!(0));

1375

}

1376

1377

pango_layout_index_to_line_x (label->layout, index[0], FALSE(0), &line_no, NULL((void*)0));

1378

layout_line = pango_layout_get_line_readonly (label->layout, line_no);

1379

if (layout_line == NULL((void*)0))

1380

return FALSE(0);

1381

1382

text = pango_layout_get_text (label->layout);

1383

if (index[0] < layout_line->start_index + layout_line->length)

1384

{

1385

/* this may be a zero-width character in the middle of the line,

1386

* or it could be a character where line is wrapped, we do want

1387

* block cursor in latter case */

1388

if (g_utf8_next_char (text + index[0])((text + index[0]) + g_utf8_skip[*(const guchar *)(text + index
[0])]) - text !=

1389

layout_line->start_index + layout_line->length)

1390

{

1391

/* zero-width character in the middle of the line, do not

1392

* bother with block cursor */

1393

return FALSE(0);

1394

}

1395

}

1396

1397

/* Cursor is at the line end. It may be an empty line, or it could

1398

* be on the left or on the right depending on text direction, or it

1399

* even could be in the middle of visual layout in bidi text. */

1400

1401

pango_layout_get_cursor_pos (label->layout, index[0], &strong_pos, &weak_pos);

1402

1403

if (strong_pos.x != weak_pos.x)

1404

{

1405

/* do not show block cursor in this case, since the character typed

1406

* in may or may not appear at the cursor position */

1407

return FALSE(0);

1408

}

1409

1410

context = pango_layout_get_context (label->layout);

1411

1412

/* In case when index points to the end of line, pos->x is always most right

1413

* pixel of the layout line, so we need to correct it for RTL text. */

1414

if (layout_line->length)

1415

{

1416

if (layout_line->resolved_dir == PANGO_DIRECTION_RTL)

1417

{

1418

PangoLayoutIter *iter;

1419

PangoRectangle line_rect;

1420

gint i;

1421

gint left, right;

1422

const gchar *p;

1423

1424

p = g_utf8_prev_char (text + index[0]);

1425

1426

pango_layout_line_index_to_x (layout_line, p - text, FALSE(0), &left);

1427

pango_layout_line_index_to_x (layout_line, p - text, TRUE(!(0)), &right);

1428

pos->x = MIN (left, right)(((left) < (right)) ? (left) : (right));

1429

1430

iter = pango_layout_get_iter (label->layout);

1431

for (i = 0; i < line_no; i++)

1432

pango_layout_iter_next_line (iter);

1433

pango_layout_iter_get_line_extents (iter, NULL((void*)0), &line_rect);

1434

pango_layout_iter_free (iter);

1435

1436

rtl = TRUE(!(0));

1437

pos->x += line_rect.x;

1438

}

1439

else

1440

rtl = FALSE(0);

1441

}

1442

else

1443

{

1444

rtl = pango_context_get_base_dir (context) == PANGO_DIRECTION_RTL;

1445

}

1446

1447

font_desc = pango_layout_get_font_description (label->layout);

1448

if (!font_desc)

1449

font_desc = pango_context_get_font_description (context);

1450

1451

metrics = pango_context_get_metrics (context, font_desc, NULL((void*)0));

1452

pos->width = pango_font_metrics_get_approximate_char_width (metrics);

1453

pango_font_metrics_unref (metrics);

1454

1455

if (rtl)

1456

pos->x -= pos->width - 1;

1457

1458

if (at_line_end)

1459

*at_line_end = TRUE(!(0));

1460

1461

return pos->width != 0;

1462

}

1463

1464

1465

/* These functions are copies from ctk+, as they are not exported from ctk+ */

1466

1467

static void

1468

eel_editable_label_draw_cursor (EelEditableLabel *label, cairo_t *cr, gint xoffset, gint yoffset)

1469

{

1470

if (ctk_widget_is_drawable (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))))

1471

{

1472

CtkWidget *widget = CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))));

1473

1474

gboolean block;

1475

gboolean block_at_line_end;

1476

gint range[2];

1477

gint index;

1478

CtkStyleContext *context;

1479

PangoRectangle strong_pos;

1480

1481

context = ctk_widget_get_style_context (widget);

1482

index = eel_editable_label_get_cursor_pos (label, NULL((void*)0), NULL((void*)0));

1483

1484

if (label->overwrite_mode &&

1485

eel_editable_label_get_block_cursor_location (label, range,

1486

&strong_pos,

1487

&block_at_line_end))

1488

block = TRUE(!(0));

1489

else

1490

block = FALSE(0);

1491

1492

if (!block)

1493

{

1494

ctk_render_insertion_cursor (context, cr,

1495

xoffset, yoffset,

1496

label->layout, index,

1497

cdk_keymap_get_direction (cdk_keymap_get_for_display (ctk_widget_get_display (widget))));

1498

}

1499

else /* Block cursor */

1500

{

1501

CdkRGBA fg_color;

1502

1503

ctk_style_context_get_color (context, CTK_STATE_FLAG_NORMAL, &fg_color);

1504

1505

cairo_save (cr);

1506

cdk_cairo_set_source_rgba (cr, &fg_color);

1507

cairo_rectangle (cr,

1508

xoffset + PANGO_PIXELS (strong_pos.x)(((int)(strong_pos.x) + 512) >> 10),

1509

yoffset + PANGO_PIXELS (strong_pos.y)(((int)(strong_pos.y) + 512) >> 10),

1510

PANGO_PIXELS (strong_pos.width)(((int)(strong_pos.width) + 512) >> 10),

1511

PANGO_PIXELS (strong_pos.height)(((int)(strong_pos.height) + 512) >> 10));

1512

cairo_fill (cr);

1513

1514

if (!block_at_line_end)

1515

{

1516

CdkRGBA color;

1517

CdkRGBA *c;

1518

cairo_region_t *clip;

1519

1520

clip = cdk_pango_layout_get_clip_region (label->layout,

1521

xoffset, yoffset,

1522

range, 1);

1523

1524

cdk_cairo_region (cr, clip);

1525

cairo_clip (cr);

1526

1527

ctk_style_context_get (context, CTK_STATE_FLAG_FOCUSED,

1528

CTK_STYLE_PROPERTY_BACKGROUND_COLOR"background-color",

1529

&c, NULL((void*)0));

1530

color = *c;

1531

cdk_rgba_free (c);

1532

1533

cdk_cairo_set_source_rgba (cr,

1534

&color);

1535

cairo_move_to (cr, xoffset, yoffset);

1536

pango_cairo_show_layout (cr, label->layout);

1537

1538

cairo_region_destroy (clip);

1539

}

1540

1541

cairo_restore (cr);

1542

}

1543

}

1544

}

1545

1546

1547

static gint

1548

eel_editable_label_draw (CtkWidget *widget,

1549

cairo_t *cr)

1550

{

1551

EelEditableLabel *label;

1552

CtkStyleContext *style;

1553

gint x, y;

1554

1555

g_assert (EEL_IS_EDITABLE_LABEL (widget))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((widget)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 1555
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL (widget)"
); } while (0);

1556

1557

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1558

style = ctk_widget_get_style_context (widget);

1559

1560

ctk_render_background (style, cr,

1561

0, 0,

1562

ctk_widget_get_allocated_width (widget),

1563

ctk_widget_get_allocated_height (widget));

1564

1565

eel_editable_label_ensure_layout (label, TRUE(!(0)));

1566

1567

if (ctk_widget_get_visible (widget) && ctk_widget_get_mapped (widget) &&

1568

label->text)

1569

{

1570

get_layout_location (label, &x, &y);

1571

1572

ctk_render_layout (style,

1573

cr,

1574

x, y,

1575

label->layout);

1576

1577

if (label->selection_anchor != label->selection_end)

1578

{

1579

gint range[2];

1580

cairo_region_t *clip;

1581

CtkStateType state;

1582

1583

CdkRGBA background_color;

1584

CdkRGBA *c;

1585

1586

range[0] = label->selection_anchor;

1587

range[1] = label->selection_end;

1588

1589

/* Handle possible preedit string */

1590

if (label->preedit_length > 0 &&

1591

range[1] > label->selection_anchor)

1592

{

1593

const char *text;

1594

1595

text = pango_layout_get_text (label->layout) + label->selection_anchor;

1596

range[1] += g_utf8_offset_to_pointer (text, label->preedit_length) - text;

1597

}

1598

1599

if (range[0] > range[1])

1600

{

1601

gint tmp = range[0];

1602

range[0] = range[1];

1603

range[1] = tmp;

1604

}

1605

1606

clip = cdk_pango_layout_get_clip_region (label->layout,

1607

x, y,

1608

range,

1609

1);

1610

1611

cairo_save (cr);

1612

1613

cdk_cairo_region (cr, clip);

1614

cairo_clip (cr);

1615

1616

state = ctk_widget_get_state_flags (widget);

1617

state |= CTK_STATE_FLAG_SELECTED;

1618

1619

ctk_style_context_get (style, state,

1620

CTK_STYLE_PROPERTY_BACKGROUND_COLOR"background-color",

1621

&c, NULL((void*)0));

1622

background_color = *c;

1623

cdk_rgba_free (c);

1624

1625

cdk_cairo_set_source_rgba (cr, &background_color);

1626

cairo_paint (cr);

1627

1628

ctk_style_context_save (style);

1629

ctk_style_context_set_state (style, state);

1630

1631

ctk_render_layout (style, cr,

1632

x, y, label->layout);

1633

1634

ctk_style_context_restore (style);

1635

1636

cairo_restore (cr);

1637

1638

cairo_region_destroy (clip);

1639

}

1640

else if (ctk_widget_has_focus (widget))

1641

eel_editable_label_draw_cursor (label, cr, x, y);

1642

1643

if (label->draw_outline)

1644

{

1645

ctk_style_context_save (style);

1646

ctk_style_context_set_state (style, ctk_widget_get_state_flags (widget));

1647

1648

ctk_render_frame (style, cr,

1649

0, 0,

1650

ctk_widget_get_allocated_width (widget),

1651

ctk_widget_get_allocated_height (widget));

1652

1653

ctk_style_context_restore (style);

1654

}

1655

}

1656

1657

return FALSE(0);

1658

}

1659

1660

static void

1661

eel_editable_label_realize (CtkWidget *widget)

1662

{

1663

EelEditableLabel *label;

1664

CdkDisplay *display;

1665

CdkWindowAttr attributes;

1666

gint attributes_mask;

1667

CtkAllocation allocation;

1668

CdkWindow *window;

1669

1670

ctk_widget_set_realized (widget, TRUE(!(0)));

1671

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1672

ctk_widget_get_allocation (widget, &allocation);

1673

1674

attributes.wclass = CDK_INPUT_OUTPUT;

1675

attributes.window_type = CDK_WINDOW_CHILD;

1676

attributes.x = allocation.x;

1677

attributes.y = allocation.y;

1678

attributes.width = allocation.width;

1679

attributes.height = allocation.height;

1680

attributes.visual = ctk_widget_get_visual (widget);

1681

display = ctk_widget_get_display (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

1682

attributes.cursor = cdk_cursor_new_for_display (display, CDK_XTERM);

1683

attributes.event_mask = ctk_widget_get_events (widget) |

1684

(CDK_EXPOSURE_MASK |

1685

CDK_BUTTON_PRESS_MASK |

1686

CDK_BUTTON_RELEASE_MASK |

1687

CDK_BUTTON1_MOTION_MASK |

1688

CDK_BUTTON3_MOTION_MASK |

1689

CDK_POINTER_MOTION_HINT_MASK |

1690

CDK_POINTER_MOTION_MASK |

1691

CDK_ENTER_NOTIFY_MASK |

1692

CDK_LEAVE_NOTIFY_MASK);

1693

1694

attributes_mask = CDK_WA_X | CDK_WA_Y | CDK_WA_VISUAL | CDK_WA_CURSOR;

1695

1696

window = cdk_window_new (ctk_widget_get_parent_window (widget),

1697

&attributes, attributes_mask);

1698

ctk_widget_set_window (widget, window);

1699

cdk_window_set_user_data (window, widget);

1700

1701

g_object_unref (attributes.cursor);

1702

1703

ctk_im_context_set_client_window (label->im_context, ctk_widget_get_window (widget));

1704

}

1705

1706

static void

1707

eel_editable_label_unrealize (CtkWidget *widget)

1708

{

1709

EelEditableLabel *label;

1710

1711

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1712

1713

/* Strange. Copied from CtkEntry, should be NULL? */

1714

ctk_im_context_set_client_window (label->im_context, NULL((void*)0));

1715

1716

(* CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->unrealize) (widget);

1717

}

1718

1719

static void

1720

eel_editable_label_map (CtkWidget *widget)

1721

{

1722

(* CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->map) (widget);

1723

}

1724

1725

static void

1726

eel_editable_label_unmap (CtkWidget *widget)

1727

{

1728

(* CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->unmap) (widget);

1729

}

1730

1731

static void

1732

window_to_layout_coords (EelEditableLabel *label,

1733

gint *x,

1734

gint *y)

1735

{

1736

gint lx, ly;

1737

1738

/* get layout location in ctk_widget_get_window (widget) coords */

1739

get_layout_location (label, &lx, &ly);

1740

1741

if (x)

1742

*x -= lx; /* go to layout */

1743

1744

if (y)

1745

*y -= ly; /* go to layout */

1746

}

1747

1748

static void

1749

get_layout_index (EelEditableLabel *label,

1750

gint x,

1751

gint y,

1752

gint *index)

1753

{

1754

gint trailing = 0;

1755

const gchar *cluster;

1756

const gchar *cluster_end;

1757

1758

*index = 0;

1759

1760

eel_editable_label_ensure_layout (label, TRUE(!(0)));

1761

1762

window_to_layout_coords (label, &x, &y);

1763

1764

x *= PANGO_SCALE1024;

1765

y *= PANGO_SCALE1024;

1766

1767

pango_layout_xy_to_index (label->layout,

1768

x, y,

1769

index, &trailing);

1770

1771

if (*index >= label->selection_anchor && label->preedit_length)

1772

{

1773

if (*index >= label->selection_anchor + label->preedit_length)

1774

*index -= label->preedit_length;

1775

else

1776

{

1777

*index = label->selection_anchor;

1778

trailing = 0;

1779

}

1780

}

1781

1782

cluster = label->text + *index;

1783

cluster_end = cluster;

1784

while (trailing)

1785

{

1786

cluster_end = g_utf8_next_char (cluster_end)((cluster_end) + g_utf8_skip[*(const guchar *)(cluster_end)]);

1787

--trailing;

1788

}

1789

1790

*index += (cluster_end - cluster);

1791

}

1792

1793

static void

1794

eel_editable_label_select_word (EelEditableLabel *label)

1795

{

1796

gint min, max;

1797

1798

gint start_index = eel_editable_label_move_backward_word (label, label->selection_end);

1799

gint end_index = eel_editable_label_move_forward_word (label, label->selection_end);

1800

1801

min = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1802

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1803

max = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1804

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1805

1806

min = MIN (min, start_index)(((min) < (start_index)) ? (min) : (start_index));

1807

max = MAX (max, end_index)(((max) > (end_index)) ? (max) : (end_index));

1808

1809

eel_editable_label_select_region_index (label, min, max);

1810

}

1811

1812

static gint

1813

eel_editable_label_button_press (CtkWidget *widget,

1814

CdkEventButton *event)

1815

{

1816

EelEditableLabel *label;

1817

gint index = 0;

1818

1819

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1820

1821

if (event->button == 1)

1822

{

1823

if (!ctk_widget_has_focus (widget))

1824

ctk_widget_grab_focus (widget);

1825

1826

if (event->type == CDK_3BUTTON_PRESS)

1827

{

1828

eel_editable_label_select_region_index (label, 0, strlen (label->text));

1829

return TRUE(!(0));

1830

}

1831

1832

if (event->type == CDK_2BUTTON_PRESS)

1833

{

1834

eel_editable_label_select_word (label);

1835

return TRUE(!(0));

1836

}

1837

1838

get_layout_index (label, event->x, event->y, &index);

1839

1840

if ((label->selection_anchor !=

1841

label->selection_end) &&

1842

(event->state & CDK_SHIFT_MASK))

1843

{

1844

gint min, max;

1845

1846

/* extend (same as motion) */

1847

min = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1848

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1849

max = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1850

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1851

1852

min = MIN (min, index)(((min) < (index)) ? (min) : (index));

1853

max = MAX (max, index)(((max) > (index)) ? (max) : (index));

1854

1855

/* ensure the anchor is opposite index */

1856

if (index == min)

1857

{

1858

gint tmp = min;

1859

min = max;

1860

max = tmp;

1861

}

1862

1863

eel_editable_label_select_region_index (label, min, max);

1864

}

1865

else

1866

{

1867

if (event->type == CDK_3BUTTON_PRESS)

1868

eel_editable_label_select_region_index (label, 0, strlen (label->text));

1869

else if (event->type == CDK_2BUTTON_PRESS)

1870

eel_editable_label_select_word (label);

1871

else

1872

/* start a replacement */

1873

eel_editable_label_select_region_index (label, index, index);

1874

}

1875

1876

return TRUE(!(0));

1877

}

1878

else if (event->button == 2 && event->type == CDK_BUTTON_PRESS)

1879

{

1880

get_layout_index (label, event->x, event->y, &index);

1881

1882

eel_editable_label_select_region_index (label, index, index);

1883

eel_editable_label_paste (label, CDK_SELECTION_PRIMARY((CdkAtom)((gpointer) (gulong) (1))));

1884

1885

return TRUE(!(0));

1886

}

1887

else if (event->button == 3 && event->type == CDK_BUTTON_PRESS)

1888

{

1889

eel_editable_label_do_popup (label, event);

1890

1891

return TRUE(!(0));

1892

1893

}

1894

return FALSE(0);

1895

}

1896

1897

static gint

1898

eel_editable_label_button_release (CtkWidget *widget G_GNUC_UNUSED__attribute__ ((__unused__)),

1899

CdkEventButton *event)

1900

1901

{

1902

if (event->button != 1)

1903

return FALSE(0);

1904

1905

/* The goal here is to return TRUE iff we ate the

1906

* button press to start selecting.

1907

*/

1908

1909

return TRUE(!(0));

1910

}

1911

1912

static gint

1913

eel_editable_label_motion (CtkWidget *widget,

1914

CdkEventMotion *event)

1915

{

1916

EelEditableLabel *label;

1917

gint index;

1918

gint x, y;

1919

1920

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

1921

1922

if ((event->state & CDK_BUTTON1_MASK) == 0)

1923

return FALSE(0);

1924

1925

cdk_window_get_device_position (ctk_widget_get_window (widget),

1926

event->device,

1927

&x, &y, NULL((void*)0));

1928

1929

get_layout_index (label, x, y, &index);

1930

1931

eel_editable_label_select_region_index (label,

1932

label->selection_anchor,

1933

index);

1934

1935

return TRUE(!(0));

1936

}

1937

1938

static void

1939

get_text_callback (CtkClipboard *clipboard G_GNUC_UNUSED__attribute__ ((__unused__)),

1940

CtkSelectionData *selection_data,

1941

guint info G_GNUC_UNUSED__attribute__ ((__unused__)),

1942

gpointer user_data_or_owner)

1943

{

1944

EelEditableLabel *label;

1945

1946

label = EEL_EDITABLE_LABEL (user_data_or_owner)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((user_data_or_owner)), (eel_editable_label_get_type
())))));

1947

1948

if ((label->selection_anchor != label->selection_end) &&

1949

label->text)

1950

{

1951

gint start, end;

1952

gint len;

1953

1954

start = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1955

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1956

end = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

1957

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

1958

1959

len = strlen (label->text);

1960

1961

if (end > len)

1962

end = len;

1963

1964

if (start > len)

1965

start = len;

1966

1967

ctk_selection_data_set_text (selection_data,

1968

label->text + start,

1969

end - start);

1970

}

1971

}

1972

1973

static void

1974

clear_text_callback (CtkClipboard *clipboard G_GNUC_UNUSED__attribute__ ((__unused__)),

1975

gpointer user_data_or_owner)

1976

{

1977

EelEditableLabel *label;

1978

1979

label = EEL_EDITABLE_LABEL (user_data_or_owner)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((user_data_or_owner)), (eel_editable_label_get_type
())))));

1980

1981

label->selection_anchor = label->selection_end;

1982

1983

ctk_widget_queue_draw (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

1984

}

1985

1986

static void

1987

eel_editable_label_select_region_index (EelEditableLabel *label,

1988

gint anchor_index,

1989

gint end_index)

1990

{

1991

CtkClipboard *clipboard;

1992

1993

g_assert (EEL_IS_EDITABLE_LABEL (label))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 1993
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL (label)"
); } while (0);

1994

1995

1996

if (label->selection_anchor == anchor_index &&

1997

label->selection_end == end_index)

1998

return;

1999

2000

eel_editable_label_reset_im_context (label);

2001

2002

label->selection_anchor = anchor_index;

2003

label->selection_end = end_index;

2004

2005

clipboard = ctk_clipboard_get (CDK_SELECTION_PRIMARY((CdkAtom)((gpointer) (gulong) (1))));

2006

2007

if (anchor_index != end_index)

2008

{

2009

CtkTargetList *list;

2010

CtkTargetEntry *targets;

2011

gint n_targets;

2012

2013

list = ctk_target_list_new (NULL((void*)0), 0);

2014

ctk_target_list_add_text_targets (list, 0);

2015

targets = ctk_target_table_new_from_list (list, &n_targets);

2016

2017

ctk_clipboard_set_with_owner (clipboard,

2018

targets, n_targets,

2019

get_text_callback,

2020

clear_text_callback,

2021

G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2022

2023

ctk_clipboard_set_can_store (clipboard, NULL((void*)0), 0);

2024

ctk_target_table_free (targets, n_targets);

2025

ctk_target_list_unref (list);

2026

}

2027

else

2028

{

2029

if (ctk_clipboard_get_owner (clipboard) == G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))))

2030

ctk_clipboard_clear (clipboard);

2031

}

2032

2033

ctk_widget_queue_draw (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2034

2035

g_object_freeze_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2036

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "cursor_position");

2037

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "selection_bound");

2038

g_object_thaw_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2039

}

2040

2041

/**

2042

* eel_editable_label_select_region:

2043

* @label: a #EelEditableLabel

2044

* @start_offset: start offset (in characters not bytes)

2045

* @end_offset: end offset (in characters not bytes)

2046

*

2047

* Selects a range of characters in the label, if the label is selectable.

2048

* See eel_editable_label_set_selectable(). If the label is not selectable,

2049

* this function has no effect. If @start_offset or

2050

* @end_offset are -1, then the end of the label will be substituted.

2051

*

2052

**/

2053

void

2054

eel_editable_label_select_region (EelEditableLabel *label,

2055

gint start_offset,

2056

gint end_offset)

2057

{

2058

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

2059

2060

if (label->text)

2061

{

2062

if (start_offset < 0)

2063

start_offset = g_utf8_strlen (label->text, -1);

2064

2065

if (end_offset < 0)

2066

end_offset = g_utf8_strlen (label->text, -1);

2067

2068

eel_editable_label_select_region_index (label,

2069

g_utf8_offset_to_pointer (label->text, start_offset) - label->text,

2070

g_utf8_offset_to_pointer (label->text, end_offset) - label->text);

2071

}

2072

}

2073

2074

/**

2075

* eel_editable_label_get_selection_bounds:

2076

* @label: a #EelEditableLabel

2077

* @start: return location for start of selection, as a character offset

2078

* @end: return location for end of selection, as a character offset

2079

*

2080

* Gets the selected range of characters in the label, returning %TRUE

2081

* if there's a selection.

2082

*

2083

* Return value: %TRUE if selection is non-empty

2084

**/

2085

gboolean

2086

eel_editable_label_get_selection_bounds (EelEditableLabel *label,

2087

gint *start,

2088

gint *end)

2089

{

2090

gint start_index, end_index;

2091

gint start_offset, end_offset;

2092

gint len;

2093

2094

g_return_val_if_fail (EEL_IS_EDITABLE_LABEL (label), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return ((0)); } } while
(0);

2095

2096

2097

start_index = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2098

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2099

end_index = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2100

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2101

2102

len = strlen (label->text);

2103

2104

if (end_index > len)

2105

end_index = len;

2106

2107

if (start_index > len)

2108

start_index = len;

2109

2110

start_offset = g_utf8_strlen (label->text, start_index);

2111

end_offset = g_utf8_strlen (label->text, end_index);

2112

2113

if (start_offset > end_offset)

2114

{

2115

gint tmp = start_offset;

2116

start_offset = end_offset;

2117

end_offset = tmp;

2118

}

2119

2120

if (start)

2121

*start = start_offset;

2122

2123

if (end)

2124

*end = end_offset;

2125

2126

return start_offset != end_offset;

2127

}

2128

2129

2130

/**

2131

* eel_editable_label_get_layout:

2132

* @label: a #EelEditableLabel

2133

*

2134

* Gets the #PangoLayout used to display the label.

2135

* The layout is useful to e.g. convert text positions to

2136

* pixel positions, in combination with eel_editable_label_get_layout_offsets().

2137

* The returned layout is owned by the label so need not be

2138

* freed by the caller.

2139

*

2140

* Return value: the #PangoLayout for this label

2141

**/

2142

PangoLayout*

2143

eel_editable_label_get_layout (EelEditableLabel *label)

2144

{

2145

g_return_val_if_fail (EEL_IS_EDITABLE_LABEL (label), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return (((void*)0)); } }
while (0);

2146

2147

eel_editable_label_ensure_layout (label, TRUE(!(0)));

2148

2149

return label->layout;

2150

}

2151

2152

/**

2153

* eel_editable_label_get_layout_offsets:

2154

* @label: a #EelEditableLabel

2155

* @x: location to store X offset of layout, or %NULL

2156

* @y: location to store Y offset of layout, or %NULL

2157

*

2158

* Obtains the coordinates where the label will draw the #PangoLayout

2159

* representing the text in the label; useful to convert mouse events

2160

* into coordinates inside the #PangoLayout, e.g. to take some action

2161

* if some part of the label is clicked. Of course you will need to

2162

* create a #CtkEventBox to receive the events, and pack the label

2163

* inside it, since labels are a #CTK_NO_WINDOW widget. Remember

2164

* when using the #PangoLayout functions you need to convert to

2165

* and from pixels using PANGO_PIXELS() or #PANGO_SCALE.

2166

*

2167

**/

2168

void

2169

eel_editable_label_get_layout_offsets (EelEditableLabel *label,

2170

gint *x,

2171

gint *y)

2172

{

2173

g_return_if_fail (EEL_IS_EDITABLE_LABEL (label))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((label)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
else { g_return_if_fail_warning ("Eel", ((const char*) (__func__
)), "EEL_IS_EDITABLE_LABEL (label)"); return; } } while (0);

2174

2175

get_layout_location (label, x, y);

2176

}

2177

2178

static void

2179

eel_editable_label_pend_cursor_blink (EelEditableLabel *label G_GNUC_UNUSED__attribute__ ((__unused__)))

2180

{

2181

/* TODO */

2182

}

2183

2184

static void

2185

eel_editable_label_check_cursor_blink (EelEditableLabel *label G_GNUC_UNUSED__attribute__ ((__unused__)))

2186

{

2187

/* TODO */

2188

}

2189

2190

static gint

2191

eel_editable_label_key_press (CtkWidget *widget,

2192

CdkEventKey *event)

2193

{

2194

EelEditableLabel *label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

2195

2196

eel_editable_label_pend_cursor_blink (label);

2197

2198

if (ctk_im_context_filter_keypress (label->im_context, event))

2199

{

2200

/*TODO eel_editable_label_obscure_mouse_cursor (label);*/

2201

label->need_im_reset = TRUE(!(0));

2202

return TRUE(!(0));

2203

}

2204

2205

if (CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->key_press_event (widget, event))

2206

/* Activate key bindings

2207

*/

2208

return TRUE(!(0));

2209

2210

return FALSE(0);

2211

}

2212

2213

static gint

2214

eel_editable_label_key_release (CtkWidget *widget,

2215

CdkEventKey *event)

2216

{

2217

EelEditableLabel *label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

2218

2219

if (ctk_im_context_filter_keypress (label->im_context, event))

2220

{

2221

label->need_im_reset = TRUE(!(0));

2222

return TRUE(!(0));

2223

}

2224

2225

return CTK_WIDGET_CLASS (eel_editable_label_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((eel_editable_label_parent_class)), ((ctk_widget_get_type
()))))))->key_release_event (widget, event);

2226

}

2227

2228

static void

2229

eel_editable_label_keymap_direction_changed (CdkKeymap *keymap G_GNUC_UNUSED__attribute__ ((__unused__)),

2230

EelEditableLabel *label)

2231

{

2232

ctk_widget_queue_draw (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2233

}

2234

2235

static gint

2236

eel_editable_label_focus_in (CtkWidget *widget,

2237

CdkEventFocus *event G_GNUC_UNUSED__attribute__ ((__unused__)))

2238

{

2239

EelEditableLabel *label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

2240

2241

ctk_widget_queue_draw (widget);

2242

2243

label->need_im_reset = TRUE(!(0));

2244

ctk_im_context_focus_in (label->im_context);

2245

2246

g_signal_connect (cdk_keymap_get_for_display (ctk_widget_get_display (widget)),g_signal_connect_data ((cdk_keymap_get_for_display (ctk_widget_get_display
(widget))), ("direction_changed"), (((GCallback) (eel_editable_label_keymap_direction_changed
))), (label), ((void*)0), (GConnectFlags) 0)

2247

"direction_changed",g_signal_connect_data ((cdk_keymap_get_for_display (ctk_widget_get_display
(widget))), ("direction_changed"), (((GCallback) (eel_editable_label_keymap_direction_changed
))), (label), ((void*)0), (GConnectFlags) 0)

2248

G_CALLBACK (eel_editable_label_keymap_direction_changed), label)g_signal_connect_data ((cdk_keymap_get_for_display (ctk_widget_get_display
(widget))), ("direction_changed"), (((GCallback) (eel_editable_label_keymap_direction_changed
))), (label), ((void*)0), (GConnectFlags) 0);

2249

2250

eel_editable_label_check_cursor_blink (label);

2251

2252

return FALSE(0);

2253

}

2254

2255

static gint

2256

eel_editable_label_focus_out (CtkWidget *widget,

2257

CdkEventFocus *event G_GNUC_UNUSED__attribute__ ((__unused__)))

2258

{

2259

EelEditableLabel *label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

2260

2261

ctk_widget_queue_draw (widget);

2262

2263

label->need_im_reset = TRUE(!(0));

2264

ctk_im_context_focus_out (label->im_context);

2265

2266

eel_editable_label_check_cursor_blink (label);

2267

2268

g_signal_handlers_disconnect_by_func (cdk_keymap_get_for_display (ctk_widget_get_display (widget)),g_signal_handlers_disconnect_matched ((cdk_keymap_get_for_display
(ctk_widget_get_display (widget))), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC
| G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0), ((gpointer) eel_editable_label_keymap_direction_changed
), (label))

2269

(gpointer) eel_editable_label_keymap_direction_changed,g_signal_handlers_disconnect_matched ((cdk_keymap_get_for_display
(ctk_widget_get_display (widget))), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC
| G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0), ((gpointer) eel_editable_label_keymap_direction_changed
), (label))

2270

label)g_signal_handlers_disconnect_matched ((cdk_keymap_get_for_display
(ctk_widget_get_display (widget))), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC
| G_SIGNAL_MATCH_DATA), 0, 0, ((void*)0), ((gpointer) eel_editable_label_keymap_direction_changed
), (label));

2271

2272

return FALSE(0);

2273

}

2274

2275

static void

2276

eel_editable_label_delete_text (EelEditableLabel *label,

2277

int start_pos,

2278

int end_pos)

2279

{

2280

if (start_pos < 0)

2281

start_pos = 0;

2282

if (end_pos < 0 || end_pos > label->n_bytes)

2283

end_pos = label->n_bytes;

2284

2285

if (start_pos < end_pos)

2286

{

2287

int anchor, end;

2288

2289

memmove (label->text + start_pos, label->text + end_pos, label->n_bytes + 1 - end_pos);

2290

label->n_bytes -= (end_pos - start_pos);

2291

2292

anchor = label->selection_anchor;

2293

if (anchor > start_pos)

2294

anchor -= MIN (anchor, end_pos)(((anchor) < (end_pos)) ? (anchor) : (end_pos)) - start_pos;

2295

2296

end = label->selection_end;

2297

if (end > start_pos)

2298

end -= MIN (end, end_pos)(((end) < (end_pos)) ? (end) : (end_pos)) - start_pos;

2299

2300

/* We might have changed the selection */

2301

eel_editable_label_select_region_index (label, anchor, end);

2302

2303

eel_editable_label_recompute (label);

2304

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2305

2306

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "text");

2307

g_signal_emit_by_name (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), "changed");

2308

}

2309

}

2310

2311

static void

2312

eel_editable_label_insert_text (EelEditableLabel *label,

2313

const gchar *new_text,

2314

gint new_text_length,

2315

gint *index)

2316

{

2317

if (new_text_length + label->n_bytes + 1 > label->text_size)

2318

{

2319

while (new_text_length + label->n_bytes + 1 > label->text_size)

2320

{

2321

if (label->text_size == 0)

2322

label->text_size = 16;

2323

else

2324

label->text_size *= 2;

2325

}

2326

2327

label->text = g_realloc (label->text, label->text_size);

2328

}

2329

2330

g_object_freeze_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2331

2332

memmove (label->text + *index + new_text_length, label->text + *index, label->n_bytes - *index);

2333

memmove (label->text + *index, new_text, new_text_length);

2334

2335

label->n_bytes += new_text_length;

2336

2337

/* NUL terminate for safety and convenience */

2338

label->text[label->n_bytes] = '\0';

2339

2340

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "text");

2341

2342

if (label->selection_anchor > *index)

2343

{

2344

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "cursor_position");

2345

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "selection_bound");

2346

label->selection_anchor += new_text_length;

2347

}

2348

2349

if (label->selection_end > *index)

2350

{

2351

label->selection_end += new_text_length;

2352

g_object_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))), "selection_bound");

2353

}

2354

2355

*index += new_text_length;

2356

2357

eel_editable_label_recompute (label);

2358

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2359

2360

g_object_thaw_notify (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2361

g_signal_emit_by_name (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), "changed");

2362

}

2363

2364

/* Used for im_commit_cb and inserting Unicode chars */

2365

static void

2366

eel_editable_label_enter_text (EelEditableLabel *label,

2367

const gchar *str)

2368

{

2369

CtkEditable *editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

2370

gint tmp_pos;

2371

gboolean old_need_im_reset;

2372

2373

/* Never reset the im while commiting, as that resets possible im state */

2374

old_need_im_reset = label->need_im_reset;

2375

label->need_im_reset = FALSE(0);

2376

2377

if (label->selection_end != label->selection_anchor)

2378

ctk_editable_delete_selection (editable);

2379

else

2380

{

2381

if (label->overwrite_mode)

2382

eel_editable_label_delete_from_cursor (label, CTK_DELETE_CHARS, 1);

2383

}

2384

2385

tmp_pos = g_utf8_pointer_to_offset (label->text,

2386

label->text + label->selection_anchor);

2387

ctk_editable_insert_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), str, strlen (str), &tmp_pos);

2388

tmp_pos = g_utf8_offset_to_pointer (label->text, tmp_pos) - label->text;

2389

eel_editable_label_select_region_index (label, tmp_pos, tmp_pos);

2390

2391

label->need_im_reset = old_need_im_reset;

2392

}

2393

2394

/* IM Context Callbacks

2395

*/

2396

2397

static void

2398

eel_editable_label_commit_cb (CtkIMContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),

2399

const gchar *str,

2400

EelEditableLabel *label)

2401

{

2402

eel_editable_label_enter_text (label, str);

2403

}

2404

2405

static void

2406

eel_editable_label_preedit_changed_cb (CtkIMContext *context G_GNUC_UNUSED__attribute__ ((__unused__)),

2407

EelEditableLabel *label)

2408

{

2409

gchar *preedit_string;

2410

gint cursor_pos;

2411

2412

ctk_im_context_get_preedit_string (label->im_context,

2413

&preedit_string, NULL((void*)0),

2414

&cursor_pos);

2415

label->preedit_length = strlen (preedit_string);

2416

cursor_pos = CLAMP (cursor_pos, 0, g_utf8_strlen (preedit_string, -1))(((cursor_pos) > (g_utf8_strlen (preedit_string, -1))) ? (
g_utf8_strlen (preedit_string, -1)) : (((cursor_pos) < (0)
) ? (0) : (cursor_pos)));

2417

label->preedit_cursor = cursor_pos;

2418

g_free (preedit_string);

2419

2420

eel_editable_label_recompute (label);

2421

ctk_widget_queue_resize (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2422

}

2423

2424

static gboolean

2425

eel_editable_label_retrieve_surrounding_cb (CtkIMContext *context,

2426

EelEditableLabel *label)

2427

{

2428

ctk_im_context_set_surrounding (context,

2429

label->text,

2430

strlen (label->text) + 1,

2431

label->selection_end);

2432

2433

return TRUE(!(0));

2434

}

2435

2436

static gboolean

2437

eel_editable_label_delete_surrounding_cb (CtkIMContext *slave G_GNUC_UNUSED__attribute__ ((__unused__)),

2438

gint offset,

2439

gint n_chars,

2440

EelEditableLabel *label)

2441

{

2442

gint current_pos;

2443

2444

current_pos = g_utf8_pointer_to_offset (label->text, label->text + label->selection_anchor);

2445

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))),

2446

current_pos + offset,

2447

current_pos + offset + n_chars);

2448

2449

return TRUE(!(0));

2450

}

2451

2452

static gboolean

2453

eel_editable_label_focus (CtkWidget *widget G_GNUC_UNUSED__attribute__ ((__unused__)),

2454

CtkDirectionType direction G_GNUC_UNUSED__attribute__ ((__unused__)))

2455

{

2456

/* We never want to be in the tab chain */

2457

return FALSE(0);

2458

}

2459

2460

/* Compute the X position for an offset that corresponds to the "more important

2461

* cursor position for that offset. We use this when trying to guess to which

2462

* end of the selection we should go to when the user hits the left or

2463

* right arrow key.

2464

*/

2465

static void

2466

get_better_cursor (EelEditableLabel *label,

2467

gint index G_GNUC_UNUSED__attribute__ ((__unused__)),

2468

gint *x,

2469

gint *y)

2470

{

2471

CtkTextDirection keymap_direction =

2472

(cdk_keymap_get_direction (cdk_keymap_get_for_display (ctk_widget_get_display (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))))) == PANGO_DIRECTION_LTR) ?

2473

CTK_TEXT_DIR_LTR : CTK_TEXT_DIR_RTL;

2474

CtkTextDirection widget_direction = ctk_widget_get_direction (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2475

gboolean split_cursor;

2476

PangoRectangle strong_pos, weak_pos;

2477

2478

g_object_get (ctk_widget_get_settings (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))),

2479

"ctk-split-cursor", &split_cursor,

2480

NULL((void*)0));

2481

2482

eel_editable_label_get_cursor_pos (label, &strong_pos, &weak_pos);

2483

2484

if (split_cursor)

2485

{

2486

*x = strong_pos.x / PANGO_SCALE1024;

2487

*y = strong_pos.y / PANGO_SCALE1024;

2488

}

2489

else

2490

{

2491

if (keymap_direction == widget_direction)

2492

{

2493

*x = strong_pos.x / PANGO_SCALE1024;

2494

*y = strong_pos.y / PANGO_SCALE1024;

2495

}

2496

else

2497

{

2498

*x = weak_pos.x / PANGO_SCALE1024;

2499

*y = weak_pos.y / PANGO_SCALE1024;

2500

}

2501

}

2502

}

2503

2504

2505

static gint

2506

eel_editable_label_move_logically (EelEditableLabel *label,

2507

gint start,

2508

gint count)

2509

{

2510

gint offset = g_utf8_pointer_to_offset (label->text,

2511

label->text + start);

2512

2513

if (label->text)

2514

{

2515

PangoLogAttr *log_attrs;

2516

gint n_attrs;

2517

gint length;

2518

2519

eel_editable_label_ensure_layout (label, FALSE(0));

2520

2521

length = g_utf8_strlen (label->text, -1);

2522

2523

pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);

2524

2525

while (count > 0 && offset < length)

2526

{

2527

do

2528

offset++;

2529

while (offset < length && !log_attrs[offset].is_cursor_position);

2530

2531

count--;

2532

}

2533

while (count < 0 && offset > 0)

2534

{

2535

do

2536

offset--;

2537

while (offset > 0 && !log_attrs[offset].is_cursor_position);

2538

2539

count++;

2540

}

2541

2542

g_free (log_attrs);

2543

}

2544

2545

return g_utf8_offset_to_pointer (label->text, offset) - label->text;

2546

}

2547

2548

static gint

2549

eel_editable_label_move_visually (EelEditableLabel *label,

2550

gint start,

2551

gint count)

2552

{

2553

gint index;

2554

2555

index = start;

2556

2557

while (count != 0)

2558

{

2559

int new_index, new_trailing;

2560

gboolean split_cursor;

2561

gboolean strong;

2562

2563

eel_editable_label_ensure_layout (label, FALSE(0));

2564

2565

g_object_get (ctk_widget_get_settings (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))),

2566

"ctk-split-cursor", &split_cursor,

2567

NULL((void*)0));

2568

2569

if (split_cursor)

2570

strong = TRUE(!(0));

2571

else

2572

{

2573

CtkTextDirection keymap_direction =

2574

(cdk_keymap_get_direction (cdk_keymap_get_for_display (ctk_widget_get_display (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))))) == PANGO_DIRECTION_LTR) ?

2575

CTK_TEXT_DIR_LTR : CTK_TEXT_DIR_RTL;

2576

2577

strong = keymap_direction == ctk_widget_get_direction (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

2578

}

2579

2580

if (count > 0)

2581

{

2582

pango_layout_move_cursor_visually (label->layout, strong, index, 0, 1, &new_index, &new_trailing);

2583

count--;

2584

}

2585

else

2586

{

2587

pango_layout_move_cursor_visually (label->layout, strong, index, 0, -1, &new_index, &new_trailing);

2588

count++;

2589

}

2590

2591

if (new_index < 0 || new_index == G_MAXINT2147483647)

2592

break;

2593

2594

index = new_index;

2595

2596

while (new_trailing--)

2597

index = g_utf8_next_char (label->text + new_index)((label->text + new_index) + g_utf8_skip[*(const guchar *)
(label->text + new_index)]) - label->text;

2598

}

2599

2600

return index;

2601

}

2602

2603

static gint

2604

eel_editable_label_move_line (EelEditableLabel *label,

2605

gint start,

2606

gint count)

2607

{

2608

PangoLayoutLine *line;

2609

int index;

2610

int n_lines, i;

2611

int x = 0;

2612

2613

eel_editable_label_ensure_layout (label, FALSE(0));

2614

2615

n_lines = pango_layout_get_line_count (label->layout);

2616

2617

for (i = 0; i < n_lines; i++)

2618

{

2619

line = pango_layout_get_line (label->layout, i);

2620

if (start >= line->start_index &&

2621

start <= line->start_index + line->length)

2622

{

2623

pango_layout_line_index_to_x (line, start, FALSE(0), &x);

2624

break;

2625

}

2626

}

2627

if (i == n_lines)

2628

i = n_lines - 1;

2629

2630

i += count;

2631

i = CLAMP (i, 0, n_lines - 1)(((i) > (n_lines - 1)) ? (n_lines - 1) : (((i) < (0)) ?
(0) : (i)));

2632

2633

line = pango_layout_get_line (label->layout, i);

2634

if (pango_layout_line_x_to_index (line,

2635

x,

2636

&index, NULL((void*)0)))

2637

return index;

2638

else

2639

{

2640

if (i == n_lines - 1)

2641

return line->start_index + line->length;

2642

else

2643

return line->start_index + line->length - 1;

2644

}

2645

}

2646

2647

static gint

2648

eel_editable_label_move_forward_word (EelEditableLabel *label,

2649

gint start)

2650

{

2651

gint new_pos = g_utf8_pointer_to_offset (label->text,

2652

label->text + start);

2653

gint length;

2654

2655

length = g_utf8_strlen (label->text, -1);

2656

if (new_pos < length)

2657

{

2658

PangoLogAttr *log_attrs;

2659

gint n_attrs;

2660

2661

eel_editable_label_ensure_layout (label, FALSE(0));

2662

2663

pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);

2664

2665

/* Find the next word end,

2666

(remember, n_attrs is one more than the number of of chars) */

2667

new_pos++;

2668

while (new_pos < (n_attrs - 1) && !log_attrs[new_pos].is_word_end)

2669

new_pos++;

2670

2671

g_free (log_attrs);

2672

}

2673

2674

return g_utf8_offset_to_pointer (label->text, new_pos) - label->text;

2675

}

2676

2677

2678

static gint

2679

eel_editable_label_move_backward_word (EelEditableLabel *label,

2680

gint start)

2681

{

2682

gint new_pos = g_utf8_pointer_to_offset (label->text,

2683

label->text + start);

2684

2685

if (new_pos > 0)

2686

{

2687

PangoLogAttr *log_attrs;

2688

gint n_attrs;

2689

2690

eel_editable_label_ensure_layout (label, FALSE(0));

2691

2692

pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);

2693

2694

new_pos -= 1;

2695

2696

/* Find the previous word beginning */

2697

while (new_pos > 0 && !log_attrs[new_pos].is_word_start)

2698

new_pos--;

2699

2700

g_free (log_attrs);

2701

}

2702

2703

return g_utf8_offset_to_pointer (label->text, new_pos) - label->text;

2704

}

2705

2706

static void

2707

eel_editable_label_move_cursor (EelEditableLabel *label,

2708

CtkMovementStep step,

2709

gint count,

2710

gboolean extend_selection)

2711

{

2712

gint new_pos;

2713

2714

new_pos = label->selection_end;

2715

2716

if (label->selection_end != label->selection_anchor &&

2717

!extend_selection)

2718

{

2719

/* If we have a current selection and aren't extending it, move to the

2720

* start/or end of the selection as appropriate

2721

*/

2722

switch (step)

2723

{

2724

case CTK_MOVEMENT_DISPLAY_LINES:

2725

case CTK_MOVEMENT_VISUAL_POSITIONS:

2726

{

2727

gint end_x, end_y;

2728

gint anchor_x, anchor_y;

2729

gboolean end_is_left;

2730

2731

get_better_cursor (label, label->selection_end, &end_x, &end_y);

2732

get_better_cursor (label, label->selection_anchor, &anchor_x, &anchor_y);

2733

2734

end_is_left = (end_y < anchor_y) || (end_y == anchor_y && end_x < anchor_x);

2735

2736

if (count < 0)

2737

new_pos = end_is_left ? label->selection_end : label->selection_anchor;

2738

else

2739

new_pos = !end_is_left ? label->selection_end : label->selection_anchor;

2740

2741

break;

2742

}

2743

case CTK_MOVEMENT_LOGICAL_POSITIONS:

2744

case CTK_MOVEMENT_WORDS:

2745

if (count < 0)

2746

new_pos = MIN (label->selection_end, label->selection_anchor)(((label->selection_end) < (label->selection_anchor)
) ? (label->selection_end) : (label->selection_anchor));

2747

else

2748

new_pos = MAX (label->selection_end, label->selection_anchor)(((label->selection_end) > (label->selection_anchor)
) ? (label->selection_end) : (label->selection_anchor));

2749

break;

2750

case CTK_MOVEMENT_DISPLAY_LINE_ENDS:

2751

case CTK_MOVEMENT_PARAGRAPH_ENDS:

2752

case CTK_MOVEMENT_BUFFER_ENDS:

2753

/* FIXME: Can do better here */

2754

new_pos = count < 0 ? 0 : strlen (label->text);

2755

break;

2756

case CTK_MOVEMENT_PARAGRAPHS:

2757

case CTK_MOVEMENT_PAGES:

2758

break;

2759

default:

2760

g_assert_not_reached ()do { g_assertion_message_expr ("Eel", "eel-editable-label.c",
2760, ((const char*) (__func__)), ((void*)0)); } while (0);

2761

break;

2762

}

2763

}

2764

else

2765

{

2766

switch (step)

2767

{

2768

case CTK_MOVEMENT_LOGICAL_POSITIONS:

2769

new_pos = eel_editable_label_move_logically (label, new_pos, count);

2770

break;

2771

case CTK_MOVEMENT_VISUAL_POSITIONS:

2772

new_pos = eel_editable_label_move_visually (label, new_pos, count);

2773

break;

2774

case CTK_MOVEMENT_WORDS:

2775

while (count > 0)

2776

{

2777

new_pos = eel_editable_label_move_forward_word (label, new_pos);

2778

count--;

2779

}

2780

while (count < 0)

2781

{

2782

new_pos = eel_editable_label_move_backward_word (label, new_pos);

2783

count++;

2784

}

2785

break;

2786

case CTK_MOVEMENT_DISPLAY_LINE_ENDS:

2787

case CTK_MOVEMENT_PARAGRAPH_ENDS:

2788

case CTK_MOVEMENT_BUFFER_ENDS:

2789

/* FIXME: Can do better here */

2790

new_pos = count < 0 ? 0 : strlen (label->text);

2791

break;

2792

case CTK_MOVEMENT_DISPLAY_LINES:

2793

new_pos = eel_editable_label_move_line (label, new_pos, count);

2794

break;

2795

break;

2796

case CTK_MOVEMENT_PARAGRAPHS:

2797

case CTK_MOVEMENT_PAGES:

2798

break;

2799

default:

2800

g_assert_not_reached ()do { g_assertion_message_expr ("Eel", "eel-editable-label.c",
2800, ((const char*) (__func__)), ((void*)0)); } while (0);

2801

break;

2802

}

2803

}

2804

2805

if (extend_selection)

2806

eel_editable_label_select_region_index (label,

2807

label->selection_anchor,

2808

new_pos);

2809

else

2810

eel_editable_label_select_region_index (label, new_pos, new_pos);

2811

}

2812

2813

static void

2814

eel_editable_label_reset_im_context (EelEditableLabel *label)

2815

{

2816

if (label->need_im_reset)

2817

{

2818

label->need_im_reset = 0;

2819

ctk_im_context_reset (label->im_context);

2820

}

2821

}

2822

2823

2824

static void

2825

eel_editable_label_delete_from_cursor (EelEditableLabel *label,

2826

CtkDeleteType type,

2827

gint count)

2828

{

2829

CtkEditable *editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

2830

gint start_pos = label->selection_anchor;

2831

gint end_pos = label->selection_anchor;

2832

2833

eel_editable_label_reset_im_context (label);

2834

2835

if (label->selection_anchor != label->selection_end)

2836

{

2837

ctk_editable_delete_selection (editable);

2838

return;

2839

}

2840

2841

switch (type)

2842

{

2843

case CTK_DELETE_CHARS:

2844

end_pos = eel_editable_label_move_logically (label, start_pos, count);

2845

start_pos = g_utf8_pointer_to_offset (label->text, label->text + start_pos);

2846

end_pos = g_utf8_pointer_to_offset (label->text, label->text + end_pos);

2847

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), MIN (start_pos, end_pos)(((start_pos) < (end_pos)) ? (start_pos) : (end_pos)), MAX (start_pos, end_pos)(((start_pos) > (end_pos)) ? (start_pos) : (end_pos)));

2848

break;

2849

case CTK_DELETE_WORDS:

2850

if (count < 0)

2851

{

2852

/* Move to end of current word, or if not on a word, end of previous word */

2853

end_pos = eel_editable_label_move_backward_word (label, end_pos);

2854

end_pos = eel_editable_label_move_forward_word (label, end_pos);

2855

}

2856

else if (count > 0)

2857

{

2858

/* Move to beginning of current word, or if not on a word, begining of next word */

2859

start_pos = eel_editable_label_move_forward_word (label, start_pos);

2860

start_pos = eel_editable_label_move_backward_word (label, start_pos);

2861

}

2862

2863

/* Fall through */

2864

case CTK_DELETE_WORD_ENDS:

2865

while (count < 0)

2866

{

2867

start_pos = eel_editable_label_move_backward_word (label, start_pos);

2868

count++;

2869

}

2870

while (count > 0)

2871

{

2872

end_pos = eel_editable_label_move_forward_word (label, end_pos);

2873

count--;

2874

}

2875

start_pos = g_utf8_pointer_to_offset (label->text, label->text + start_pos);

2876

end_pos = g_utf8_pointer_to_offset (label->text, label->text + end_pos);

2877

2878

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), start_pos, end_pos);

2879

break;

2880

case CTK_DELETE_DISPLAY_LINE_ENDS:

2881

case CTK_DELETE_PARAGRAPH_ENDS:

2882

end_pos = g_utf8_pointer_to_offset (label->text, label->text + label->selection_anchor);

2883

if (count < 0)

2884

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), 0, end_pos);

2885

else

2886

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), end_pos, -1);

2887

break;

2888

case CTK_DELETE_DISPLAY_LINES:

2889

case CTK_DELETE_PARAGRAPHS:

2890

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), 0, -1);

2891

break;

2892

case CTK_DELETE_WHITESPACE:

2893

/* TODO eel_editable_label_delete_whitespace (label); */

2894

break;

2895

}

2896

2897

eel_editable_label_pend_cursor_blink (label);

2898

}

2899

2900

2901

static void

2902

eel_editable_label_copy_clipboard (EelEditableLabel *label)

2903

{

2904

if (label->text)

2905

{

2906

gint start, end;

2907

gint len;

2908

2909

start = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2910

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2911

end = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2912

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2913

2914

len = strlen (label->text);

2915

2916

if (end > len)

2917

end = len;

2918

2919

if (start > len)

2920

start = len;

2921

2922

if (start != end)

2923

ctk_clipboard_set_text (ctk_clipboard_get (CDK_SELECTION_CLIPBOARD((CdkAtom)((gpointer) (gulong) (69)))),

2924

label->text + start, end - start);

2925

}

2926

}

2927

2928

static void

2929

eel_editable_label_cut_clipboard (EelEditableLabel *label)

2930

{

2931

if (label->text)

2932

{

2933

gint start, end;

2934

gint len;

2935

2936

start = MIN (label->selection_anchor,(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2937

label->selection_end)(((label->selection_anchor) < (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2938

end = MAX (label->selection_anchor,(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end))

2939

label->selection_end)(((label->selection_anchor) > (label->selection_end)
) ? (label->selection_anchor) : (label->selection_end));

2940

2941

len = strlen (label->text);

2942

2943

if (end > len)

2944

end = len;

2945

2946

if (start > len)

2947

start = len;

2948

2949

if (start != end)

2950

{

2951

ctk_clipboard_set_text (ctk_clipboard_get (CDK_SELECTION_CLIPBOARD((CdkAtom)((gpointer) (gulong) (69)))),

2952

label->text + start, end - start);

2953

start = g_utf8_pointer_to_offset (label->text, label->text + start);

2954

end = g_utf8_pointer_to_offset (label->text, label->text + end);

2955

ctk_editable_delete_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), start, end);

2956

}

2957

}

2958

}

2959

2960

static void

2961

paste_received (CtkClipboard *clipboard G_GNUC_UNUSED__attribute__ ((__unused__)),

2962

const gchar *text,

2963

gpointer data)

2964

{

2965

EelEditableLabel *label = EEL_EDITABLE_LABEL (data)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((data)), (eel_editable_label_get_type())))));

2966

CtkEditable *editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

2967

gint tmp_pos;

2968

2969

if (text)

2970

{

2971

if (label->selection_end != label->selection_anchor)

2972

ctk_editable_delete_selection (editable);

2973

2974

tmp_pos = g_utf8_pointer_to_offset (label->text,

2975

label->text + label->selection_anchor);

2976

ctk_editable_insert_text (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), text, strlen (text), &tmp_pos);

2977

tmp_pos = g_utf8_offset_to_pointer (label->text, tmp_pos) - label->text;

2978

eel_editable_label_select_region_index (label, tmp_pos, tmp_pos);

2979

}

2980

2981

g_object_unref (G_OBJECT (label)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), (((GType) ((20) << (2)))))))));

2982

}

2983

2984

static void

2985

eel_editable_label_paste (EelEditableLabel *label,

2986

CdkAtom selection)

2987

{

2988

g_object_ref (G_OBJECT (label))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label)), (((GType) ((20) << (2))))
)))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((label)), (((GType) ((20) << (2))))
))))));

2989

ctk_clipboard_request_text (ctk_widget_get_clipboard (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))), selection),

2990

paste_received, label);

2991

}

2992

2993

static void

2994

eel_editable_label_paste_clipboard (EelEditableLabel *label)

2995

{

2996

eel_editable_label_paste (label, CDK_NONE((CdkAtom)((gpointer) (gulong) (0))));

2997

}

2998

2999

static void

3000

eel_editable_label_select_all (EelEditableLabel *label)

3001

{

3002

eel_editable_label_select_region_index (label, 0, strlen (label->text));

3003

}

3004

3005

/* Quick hack of a popup menu

3006

*/

3007

static void

3008

activate_cb (CtkWidget *menuitem,

3009

EelEditableLabel *label)

3010

{

3011

const gchar *signal = g_object_get_data (G_OBJECT (menuitem)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menuitem)), (((GType) ((20) << (2)))))))), "ctk-signal");

3012

g_signal_emit_by_name (label, signal);

3013

}

3014

3015

static void

3016

append_action_signal (EelEditableLabel *label,

3017

CtkWidget *menu,

3018

const gchar *icon_name,

3019

const gchar *label_name,

3020

const gchar *signal,

3021

gboolean sensitive)

3022

{

3023

CtkWidget *menuitem = eel_image_menu_item_new_from_icon (icon_name, label_name);

3024

3025

g_object_set_data (G_OBJECT (menuitem)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menuitem)), (((GType) ((20) << (2)))))))), "ctk-signal", (char *)signal);

3026

g_signal_connect (menuitem, "activate",g_signal_connect_data ((menuitem), ("activate"), (((GCallback
) (activate_cb))), (label), ((void*)0), (GConnectFlags) 0)

3027

G_CALLBACK (activate_cb), label)g_signal_connect_data ((menuitem), ("activate"), (((GCallback
) (activate_cb))), (label), ((void*)0), (GConnectFlags) 0);

3028

3029

ctk_widget_set_sensitive (menuitem, sensitive);

3030

3031

ctk_widget_show (menuitem);

3032

ctk_menu_shell_append (CTK_MENU_SHELL (menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((menu)), ((ctk_menu_shell_get_type ())))))), menuitem);

3033

}

3034

3035

static void

3036

popup_menu_detach (CtkWidget *attach_widget,

3037

CtkMenu *menu G_GNUC_UNUSED__attribute__ ((__unused__)))

3038

{

3039

EelEditableLabel *label;

3040

label = EEL_EDITABLE_LABEL (attach_widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((attach_widget)), (eel_editable_label_get_type
())))));

3041

3042

label->popup_menu = NULL((void*)0);

3043

}

3044

3045

static void

3046

eel_editable_label_toggle_overwrite (EelEditableLabel *label)

3047

{

3048

label->overwrite_mode = !label->overwrite_mode;

3049

ctk_widget_queue_draw (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

3050

}

3051

3052

typedef struct

3053

{

3054

EelEditableLabel *label;

3055

gint button;

3056

guint time;

3057

} PopupInfo;

3058

3059

static void

3060

popup_targets_received (CtkClipboard *clipboard G_GNUC_UNUSED__attribute__ ((__unused__)),

3061

CtkSelectionData *data,

3062

gpointer user_data)

3063

{

3064

gboolean have_selection;

3065

gboolean clipboard_contains_text;

3066

PopupInfo *info;

3067

EelEditableLabel *label;

3068

3069

info = user_data;

3070

label = info->label;

3071

3072

if (ctk_widget_get_realized (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ()))))))))

3073

{

3074

CtkWidget *menuitem;

3075

3076

if (label->popup_menu)

3077

ctk_widget_destroy (label->popup_menu);

3078

3079

label->popup_menu = ctk_menu_new ();

3080

3081

ctk_menu_set_reserve_toggle_size (CTK_MENU (label->popup_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_get_type ())))))), FALSE(0));

3082

3083

ctk_menu_attach_to_widget (CTK_MENU (label->popup_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_get_type ())))))),

3084

CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))),

3085

popup_menu_detach);

3086

3087

have_selection =

3088

label->selection_anchor != label->selection_end;

3089

3090

clipboard_contains_text = ctk_selection_data_targets_include_text (data);

3091

3092

append_action_signal (label, label->popup_menu, "edit-cut", _("Cu_t")((char *) g_dgettext ("baul", "Cu_t")), "cut_clipboard",

3093

have_selection);

3094

append_action_signal (label, label->popup_menu, "edit-copy", _("_Copy")((char *) g_dgettext ("baul", "_Copy")), "copy_clipboard",

3095

have_selection);

3096

append_action_signal (label, label->popup_menu, "edit-paste", _("_Paste")((char *) g_dgettext ("baul", "_Paste")), "paste_clipboard",

3097

clipboard_contains_text);

3098

3099

menuitem = eel_image_menu_item_new_from_icon ("edit-select-all", _("Select All")((char *) g_dgettext ("baul", "Select All")));

3100

g_signal_connect_object (menuitem, "activate",

3101

G_CALLBACK (eel_editable_label_select_all)((GCallback) (eel_editable_label_select_all)), label,

3102

G_CONNECT_SWAPPED);

3103

ctk_widget_show (menuitem);

3104

ctk_menu_shell_append (CTK_MENU_SHELL (label->popup_menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_shell_get_type ()))))
)), menuitem);

3105

3106

g_signal_emit (label,

3107

signals[POPULATE_POPUP], 0,

3108

label->popup_menu);

3109

3110

if (info->button)

3111

ctk_menu_popup_at_pointer (CTK_MENU (label->popup_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_get_type ())))))), NULL((void*)0));

3112

else

3113

{

3114

ctk_menu_popup_at_pointer (CTK_MENU (label->popup_menu)((((CtkMenu*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_get_type ())))))), NULL((void*)0));

3115

ctk_menu_shell_select_first (CTK_MENU_SHELL (label->popup_menu)((((CtkMenuShell*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label->popup_menu)), ((ctk_menu_shell_get_type ()))))
)), FALSE(0));

3116

}

3117

}

3118

3119

g_object_unref (label);

3120

g_free (info);

3121

}

3122

3123

static void

3124

eel_editable_label_do_popup (EelEditableLabel *label,

3125

CdkEventButton *event)

3126

{

3127

PopupInfo *info = g_new (PopupInfo, 1)((PopupInfo *) g_malloc_n ((1), sizeof (PopupInfo)));

3128

3129

/* In order to know what entries we should make sensitive, we

3130

* ask for the current targets of the clipboard, and when

3131

* we get them, then we actually pop up the menu.

3132

*/

3133

info->label = g_object_ref (label)((__typeof__ (label)) (g_object_ref) (label));

3134

3135

if (event)

3136

{

3137

info->button = event->button;

3138

info->time = event->time;

3139

}

3140

else

3141

{

3142

info->button = 0;

3143

info->time = ctk_get_current_event_time ();

3144

}

3145

3146

ctk_clipboard_request_contents (ctk_widget_get_clipboard (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))), CDK_SELECTION_CLIPBOARD((CdkAtom)((gpointer) (gulong) (69)))),

3147

cdk_atom_intern ("TARGETS", FALSE(0)),

3148

popup_targets_received,

3149

info);

3150

}

3151

3152

/************ Editable implementation ****************/

3153

3154

static void

3155

editable_insert_text_emit (CtkEditable *editable,

3156

const gchar *new_text,

3157

gint new_text_length,

3158

gint *position)

3159

{

3160

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3161

gchar buf[64];

3162

gchar *text;

3163

int text_length;

3164

3165

text_length = g_utf8_strlen (label->text, -1);

3166

3167

if (*position < 0 || *position > text_length)

3168

*position = text_length;

3169

3170

g_object_ref (G_OBJECT (editable))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((editable)), (((GType) ((20) << (2)
))))))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((editable)), (((GType) ((20) << (2)
)))))))));

3171

3172

if (new_text_length <= 63)

3173

text = buf;

3174

else

3175

text = g_new (gchar, new_text_length + 1)((gchar *) g_malloc_n ((new_text_length + 1), sizeof (gchar))
);

3176

3177

text[new_text_length] = '\0';

3178

strncpy (text, new_text, new_text_length);

3179

3180

g_signal_emit_by_name (editable, "insert_text", text, new_text_length, position);

3181

3182

if (new_text_length > 63)

3183

g_free (text);

3184

3185

g_object_unref (G_OBJECT (editable)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((editable)), (((GType) ((20) << (2)))))))));

3186

}

3187

3188

static void

3189

editable_delete_text_emit (CtkEditable *editable,

3190

gint start_pos,

3191

gint end_pos)

3192

{

3193

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3194

int text_length;

3195

3196

text_length = g_utf8_strlen (label->text, -1);

3197

3198

if (end_pos < 0 || end_pos > text_length)

3199

end_pos = text_length;

3200

if (start_pos < 0)

3201

start_pos = 0;

3202

if (start_pos > end_pos)

3203

start_pos = end_pos;

3204

3205

g_object_ref (G_OBJECT (editable))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((editable)), (((GType) ((20) << (2)
))))))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
((GTypeInstance*) ((editable)), (((GType) ((20) << (2)
)))))))));

3206

3207

g_signal_emit_by_name (editable, "delete_text", start_pos, end_pos);

3208

3209

g_object_unref (G_OBJECT (editable)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((editable)), (((GType) ((20) << (2)))))))));

3210

}

3211

3212

static void

3213

editable_insert_text (CtkEditable *editable,

3214

const gchar *new_text,

3215

gint new_text_length,

3216

gint *position)

3217

{

3218

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3219

gint index;

3220

3221

if (new_text_length < 0)

3222

new_text_length = strlen (new_text);

3223

3224

index = g_utf8_offset_to_pointer (label->text, *position) - label->text;

3225

3226

eel_editable_label_insert_text (label,

3227

new_text,

3228

new_text_length,

3229

&index);

3230

3231

*position = g_utf8_pointer_to_offset (label->text, label->text + index);

3232

}

3233

3234

static void

3235

editable_delete_text (CtkEditable *editable,

3236

gint start_pos,

3237

gint end_pos)

3238

{

3239

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3240

int text_length;

3241

gint start_index, end_index;

3242

3243

text_length = g_utf8_strlen (label->text, -1);

3244

3245

if (end_pos < 0 || end_pos > text_length)

3246

end_pos = text_length;

3247

if (start_pos < 0)

3248

start_pos = 0;

3249

if (start_pos > end_pos)

3250

start_pos = end_pos;

3251

3252

start_index = g_utf8_offset_to_pointer (label->text, start_pos) - label->text;

3253

end_index = g_utf8_offset_to_pointer (label->text, end_pos) - label->text;

3254

3255

eel_editable_label_delete_text (label, start_index, end_index);

3256

}

3257

3258

static gchar *

3259

editable_get_chars (CtkEditable *editable,

3260

gint start_pos,

3261

gint end_pos)

3262

{

3263

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3264

int text_length;

3265

gint start_index, end_index;

3266

3267

text_length = g_utf8_strlen (label->text, -1);

3268

3269

if (end_pos < 0 || end_pos > text_length)

3270

end_pos = text_length;

3271

if (start_pos < 0)

3272

start_pos = 0;

3273

if (start_pos > end_pos)

3274

start_pos = end_pos;

3275

3276

start_index = g_utf8_offset_to_pointer (label->text, start_pos) - label->text;

3277

end_index = g_utf8_offset_to_pointer (label->text, end_pos) - label->text;

3278

3279

return g_strndup (label->text + start_index, end_index - start_index);

3280

}

3281

3282

static void

3283

editable_set_selection_bounds (CtkEditable *editable,

3284

gint start,

3285

gint end)

3286

{

3287

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3288

int text_length;

3289

gint start_index, end_index;

3290

3291

text_length = g_utf8_strlen (label->text, -1);

3292

3293

if (end < 0 || end > text_length)

3294

end = text_length;

3295

if (start < 0)

3296

start = text_length;

3297

if (start > text_length)

3298

start = text_length;

3299

3300

eel_editable_label_reset_im_context (label);

3301

3302

start_index = g_utf8_offset_to_pointer (label->text, start) - label->text;

3303

end_index = g_utf8_offset_to_pointer (label->text, end) - label->text;

3304

3305

eel_editable_label_select_region_index (label, start_index, end_index);

3306

}

3307

3308

static gboolean

3309

editable_get_selection_bounds (CtkEditable *editable,

3310

gint *start,

3311

gint *end)

3312

{

3313

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3314

3315

*start = g_utf8_pointer_to_offset (label->text, label->text + label->selection_anchor);

3316

*end = g_utf8_pointer_to_offset (label->text, label->text + label->selection_end);

3317

3318

return (label->selection_anchor != label->selection_end);

3319

}

3320

3321

static void

3322

editable_real_set_position (CtkEditable *editable,

3323

gint position)

3324

{

3325

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3326

int text_length;

3327

int index;

3328

3329

text_length = g_utf8_strlen (label->text, -1);

3330

3331

if (position < 0 || position > text_length)

3332

position = text_length;

3333

3334

index = g_utf8_offset_to_pointer (label->text, position) - label->text;

3335

3336

if (index != label->selection_anchor ||

3337

index != label->selection_end)

3338

{

3339

eel_editable_label_select_region_index (label, index, index);

3340

}

3341

}

3342

3343

static gint

3344

editable_get_position (CtkEditable *editable)

3345

{

3346

EelEditableLabel *label = EEL_EDITABLE_LABEL (editable)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((editable)), (eel_editable_label_get_type())
))));

3347

3348

return g_utf8_pointer_to_offset (label->text, label->text + label->selection_anchor);

3349

}

3350

3351

3352

static AtkObjectClass *a11y_parent_class = NULL((void*)0);

3353

3354

static const char* eel_editable_label_accessible_data = "eel-editable-label-accessible-data";

3355

3356

/************ Accessible implementation ****************/

3357

3358

typedef struct

3359

{

3360

CailTextUtil *textutil;

3361

gint selection_anchor;

3362

gint selection_end;

3363

gchar *signal_name;

3364

gint position;

3365

gint length;

3366

} EelEditableLabelAccessiblePrivate;

3367

3368

typedef struct

3369

{

3370

EelEditableLabel* label;

3371

gint position;

3372

} EelEditableLabelAccessiblePaste;

3373

3374

typedef struct _EelEditableLabelAccessible EelEditableLabelAccessible;

3375

typedef struct _EelEditableLabelAccessibleClass EelEditableLabelAccessibleClass;

3376

3377

struct _EelEditableLabelAccessible

3378

{

3379

CtkWidgetAccessible parent;

3380

};

3381

3382

struct _EelEditableLabelAccessibleClass

3383

{

3384

CtkWidgetAccessibleClass parent_class;

3385

};

3386

3387

static gchar*

3388

eel_editable_label_accessible_get_text (AtkText *text,

3389

gint start_pos,

3390

gint end_pos)

3391

{

3392

CtkWidget *widget;

3393

EelEditableLabelAccessiblePrivate *priv;

3394

3395

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3396

if (widget == NULL((void*)0))

3397

/* State is defunct */

3398

return NULL((void*)0);

3399

3400

priv = g_object_get_data (G_OBJECT (text)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

3401

return cail_text_util_get_substring (priv->textutil, start_pos, end_pos);

3402

}

3403

3404

static gunichar

3405

eel_editable_label_accessible_get_character_at_offset (AtkText *text,

3406

gint offset)

3407

{

3408

CtkWidget *widget;

3409

EelEditableLabelAccessiblePrivate *priv;

3410

gchar *string;

3411

gunichar unichar;

3412

3413

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3414

if (widget == NULL((void*)0))

3415

/* State is defunct */

3416

return '\0';

3417

3418

priv = g_object_get_data (G_OBJECT (text)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

3419

string = cail_text_util_get_substring (priv->textutil, 0, -1);

3420

if (offset >= g_utf8_strlen (string, -1))

3421

{

3422

unichar = '\0';

3423

}

3424

else

3425

{

3426

gchar *index;

3427

3428

index = g_utf8_offset_to_pointer (string, offset);

3429

3430

unichar = g_utf8_get_char(index);

3431

}

3432

3433

g_free(string);

3434

return unichar;

3435

}

3436

3437

static gchar*

3438

eel_editable_label_accessible_get_text_before_offset (AtkText *text,

3439

gint offset,

3440

AtkTextBoundary boundary_type,

3441

gint *start_offset,

3442

gint *end_offset)

3443

{

3444

CtkWidget *widget;

3445

EelEditableLabel *label;

3446

EelEditableLabelAccessiblePrivate *priv;

3447

3448

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3449

if (widget == NULL((void*)0))

3450

/* State is defunct */

3451

return NULL((void*)0);

3452

3453

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3454

priv = g_object_get_data (G_OBJECT (text)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

3455

3456

return cail_text_util_get_text (priv->textutil,

3457

eel_editable_label_get_layout (label),

3458

CAIL_BEFORE_OFFSET,

3459

boundary_type, offset,

3460

start_offset, end_offset);

3461

}

3462

3463

static gchar*

3464

eel_editable_label_accessible_get_text_at_offset (AtkText *text,

3465

gint offset,

3466

AtkTextBoundary boundary_type,

3467

gint *start_offset,

3468

gint *end_offset)

3469

{

3470

CtkWidget *widget;

3471

EelEditableLabel *label;

3472

EelEditableLabelAccessiblePrivate *priv;

3473

3474

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3475

if (widget == NULL((void*)0))

3476

/* State is defunct */

3477

return NULL((void*)0);

3478

3479

3480

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3481

priv = g_object_get_data (G_OBJECT (text)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

3482

return cail_text_util_get_text (priv->textutil,

3483

eel_editable_label_get_layout (label),

3484

CAIL_AT_OFFSET,

3485

boundary_type, offset,

3486

start_offset, end_offset);

3487

}

3488

3489

static gchar*

3490

eel_editable_label_accessible_get_text_after_offset (AtkText *text,

3491

gint offset,

3492

AtkTextBoundary boundary_type,

3493

gint *start_offset,

3494

gint *end_offset)

3495

{

3496

CtkWidget *widget;

3497

EelEditableLabel *label;

3498

EelEditableLabelAccessiblePrivate *priv;

3499

3500

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3501

if (widget == NULL((void*)0))

3502

/* State is defunct */

3503

return NULL((void*)0);

3504

3505

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3506

priv = g_object_get_data (G_OBJECT (text)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

3507

return cail_text_util_get_text (priv->textutil,

3508

eel_editable_label_get_layout (label),

3509

CAIL_AFTER_OFFSET,

3510

boundary_type, offset,

3511

start_offset, end_offset);

3512

}

3513

3514

static gint

3515

eel_editable_label_accessible_get_caret_offset (AtkText *text)

3516

{

3517

CtkWidget *widget;

3518

3519

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3520

if (widget == NULL((void*)0))

3521

/* State is defunct */

3522

return 0;

3523

3524

return ctk_editable_get_position (CTK_EDITABLE (widget)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_editable_get_type ())))))));

3525

}

3526

3527

static gboolean

3528

eel_editable_label_accessible_set_caret_offset (AtkText *text, gint offset)

3529

{

3530

CtkWidget *widget;

3531

3532

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3533

if (widget == NULL((void*)0))

3534

/* State is defunct */

3535

return FALSE(0);

3536

3537

ctk_editable_set_position (CTK_EDITABLE (widget)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_editable_get_type ())))))), offset);

3538

return TRUE(!(0));

3539

}

3540

3541

static gint

3542

eel_editable_label_accessible_get_character_count (AtkText *text)

3543

{

3544

CtkWidget *widget;

3545

EelEditableLabel *label;

3546

3547

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3548

if (widget == NULL((void*)0))

3549

/* State is defunct */

3550

return 0;

3551

3552

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3553

return g_utf8_strlen (eel_editable_label_get_text (label), -1);

3554

}

3555

3556

static gint

3557

eel_editable_label_accessible_get_n_selections (AtkText *text)

3558

{

3559

CtkWidget *widget;

3560

EelEditableLabel *label;

3561

gint select_start, select_end;

3562

3563

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3564

if (widget == NULL((void*)0))

3565

/* State is defunct */

3566

return -1;

3567

3568

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3569

ctk_editable_get_selection_bounds (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), &select_start,

3570

&select_end);

3571

3572

if (select_start != select_end)

3573

return 1;

3574

else

3575

return 0;

3576

}

3577

3578

static gchar*

3579

eel_editable_label_accessible_get_selection (AtkText *text,

3580

gint selection_num,

3581

gint *start_pos,

3582

gint *end_pos)

3583

{

3584

CtkWidget *widget;

3585

EelEditableLabel *label;

3586

3587

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3588

if (widget == NULL((void*)0))

3589

/* State is defunct */

3590

return NULL((void*)0);

3591

3592

/* Only let the user get the selection if one is set, and if the

3593

* selection_num is 0.

3594

*/

3595

if (selection_num != 0)

3596

return NULL((void*)0);

3597

3598

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3599

ctk_editable_get_selection_bounds (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), start_pos, end_pos);

3600

3601

if (*start_pos != *end_pos)

3602

return ctk_editable_get_chars (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), *start_pos, *end_pos);

3603

else

3604

return NULL((void*)0);

3605

}

3606

3607

static gboolean

3608

eel_editable_label_accessible_add_selection (AtkText *text,

3609

gint start_pos,

3610

gint end_pos)

3611

{

3612

CtkWidget *widget;

3613

EelEditableLabel *label;

3614

gint select_start, select_end;

3615

3616

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3617

if (widget == NULL((void*)0))

3618

/* State is defunct */

3619

return FALSE(0);

3620

3621

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3622

ctk_editable_get_selection_bounds (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), &select_start,

3623

&select_end);

3624

3625

/* If there is already a selection, then don't allow another to be added,

3626

* since EelEditableLabel only supports one selected region.

3627

*/

3628

if (select_start == select_end)

3629

{

3630

ctk_editable_select_region (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), start_pos, end_pos);

3631

return TRUE(!(0));

3632

}

3633

else

3634

return FALSE(0);

3635

}

3636

3637

static gboolean

3638

eel_editable_label_accessible_remove_selection (AtkText *text,

3639

gint selection_num)

3640

{

3641

CtkWidget *widget;

3642

EelEditableLabel *label;

3643

gint select_start, select_end, caret_pos;

3644

3645

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3646

if (widget == NULL((void*)0))

3647

/* State is defunct */

3648

return FALSE(0);

3649

3650

if (selection_num != 0)

3651

return FALSE(0);

3652

3653

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3654

ctk_editable_get_selection_bounds (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), &select_start,

3655

&select_end);

3656

3657

if (select_start != select_end)

3658

{

3659

/* Setting the start & end of the selected region to the caret position

3660

* turns off the selection.

3661

*/

3662

caret_pos = ctk_editable_get_position (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))));

3663

ctk_editable_select_region (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), caret_pos, caret_pos);

3664

return TRUE(!(0));

3665

}

3666

else

3667

return FALSE(0);

3668

}

3669

3670

static gboolean

3671

eel_editable_label_accessible_set_selection (AtkText *text,

3672

gint selection_num,

3673

gint start_pos,

3674

gint end_pos)

3675

{

3676

CtkWidget *widget;

3677

EelEditableLabel *label;

3678

gint select_start, select_end;

3679

3680

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3681

if (widget == NULL((void*)0))

3682

/* State is defunct */

3683

return FALSE(0);

3684

3685

/* Only let the user move the selection if one is set, and if the

3686

* selection_num is 0

3687

*/

3688

if (selection_num != 0)

3689

return FALSE(0);

3690

3691

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3692

ctk_editable_get_selection_bounds (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), &select_start,

3693

&select_end);

3694

3695

if (select_start != select_end)

3696

{

3697

ctk_editable_select_region (CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ())))))), start_pos, end_pos);

3698

return TRUE(!(0));

3699

}

3700

else

3701

return FALSE(0);

3702

}

3703

3704

static AtkAttributeSet*

3705

eel_editable_label_accessible_get_run_attributes (AtkText *text,

3706

gint offset,

3707

gint *start_offset,

3708

gint *end_offset)

3709

{

3710

CtkWidget *widget;

3711

EelEditableLabel *label;

3712

AtkAttributeSet *at_set = NULL((void*)0);

3713

CtkTextDirection dir;

3714

3715

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3716

if (widget == NULL((void*)0))

3717

/* State is defunct */

3718

return NULL((void*)0);

3719

3720

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3721

3722

dir = ctk_widget_get_direction (widget);

3723

if (dir == CTK_TEXT_DIR_RTL)

3724

{

3725

at_set = cail_misc_add_attribute (at_set,

3726

ATK_TEXT_ATTR_DIRECTION,

3727

g_strdup (atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION, dir))g_strdup_inline (atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION
, dir)));

3728

}

3729

3730

at_set = cail_misc_layout_get_run_attributes (at_set,

3731

eel_editable_label_get_layout (label),

3732

label->text,

3733

offset,

3734

start_offset,

3735

end_offset);

3736

return at_set;

3737

}

3738

3739

static AtkAttributeSet*

3740

eel_editable_label_accessible_get_default_attributes (AtkText *text)

3741

{

3742

CtkWidget *widget;

3743

EelEditableLabel *label;

3744

AtkAttributeSet *at_set = NULL((void*)0);

3745

3746

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3747

if (widget == NULL((void*)0))

3748

/* State is defunct */

3749

return NULL((void*)0);

3750

3751

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3752

3753

at_set = cail_misc_get_default_attributes (at_set,

3754

eel_editable_label_get_layout (label),

3755

widget);

3756

return at_set;

3757

}

3758

3759

static void

3760

eel_editable_label_accessible_get_character_extents (AtkText *text,

3761

gint offset,

3762

gint *x,

3763

gint *y,

3764

gint *width,

3765

gint *height,

3766

AtkCoordType coords)

3767

{

3768

CtkWidget *widget;

3769

EelEditableLabel *label;

3770

PangoRectangle char_rect;

3771

gint index, cursor_index, x_layout, y_layout;

3772

3773

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3774

if (widget == NULL((void*)0))

3775

/* State is defunct */

3776

return;

3777

3778

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3779

eel_editable_label_get_layout_offsets (label, &x_layout, &y_layout);

3780

index = g_utf8_offset_to_pointer (label->text, offset) - label->text;

3781

cursor_index = label->selection_anchor;

3782

if (index > cursor_index)

3783

index += label->preedit_length;

3784

pango_layout_index_to_pos (eel_editable_label_get_layout(label), index, &char_rect);

3785

3786

cail_misc_get_extents_from_pango_rectangle (widget, &char_rect,

3787

x_layout, y_layout, x, y, width, height, coords);

3788

}

3789

3790

static gint

3791

eel_editable_label_accessible_get_offset_at_point (AtkText *text,

3792

gint x,

3793

gint y,

3794

AtkCoordType coords)

3795

{

3796

CtkWidget *widget;

3797

EelEditableLabel *label;

3798

gint index, cursor_index, x_layout, y_layout;

3799

3800

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3801

if (widget == NULL((void*)0))

3802

/* State is defunct */

3803

return -1;

3804

3805

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3806

3807

eel_editable_label_get_layout_offsets (label, &x_layout, &y_layout);

3808

3809

index = cail_misc_get_index_at_point_in_layout (widget,

3810

eel_editable_label_get_layout(label), x_layout, y_layout, x, y, coords);

3811

if (index == -1)

3812

{

3813

if (coords == ATK_XY_SCREEN || coords == ATK_XY_WINDOW)

3814

return g_utf8_strlen (label->text, -1);

3815

3816

return index;

3817

}

3818

else

3819

{

3820

cursor_index = label->selection_anchor;

3821

if (index >= cursor_index && label->preedit_length)

3822

{

3823

if (index >= cursor_index + label->preedit_length)

3824

index -= label->preedit_length;

3825

else

3826

index = cursor_index;

3827

}

3828

return g_utf8_pointer_to_offset (label->text, label->text + index);

3829

}

3830

}

3831

3832

static void

3833

atk_text_interface_init (AtkTextIface *iface)

3834

{

3835

g_assert (iface != NULL)do { if (iface != ((void*)0)) ; else g_assertion_message_expr
("Eel", "eel-editable-label.c", 3835, ((const char*) (__func__
)), "iface != NULL"); } while (0);

3836

3837

iface->get_text = eel_editable_label_accessible_get_text;

3838

iface->get_character_at_offset = eel_editable_label_accessible_get_character_at_offset;

3839

iface->get_text_before_offset = eel_editable_label_accessible_get_text_before_offset;

3840

iface->get_text_at_offset = eel_editable_label_accessible_get_text_at_offset;

3841

iface->get_text_after_offset = eel_editable_label_accessible_get_text_after_offset;

3842

iface->get_caret_offset = eel_editable_label_accessible_get_caret_offset;

3843

iface->set_caret_offset = eel_editable_label_accessible_set_caret_offset;

3844

iface->get_character_count = eel_editable_label_accessible_get_character_count;

3845

iface->get_n_selections = eel_editable_label_accessible_get_n_selections;

3846

iface->get_selection = eel_editable_label_accessible_get_selection;

3847

iface->add_selection = eel_editable_label_accessible_add_selection;

3848

iface->remove_selection = eel_editable_label_accessible_remove_selection;

3849

iface->set_selection = eel_editable_label_accessible_set_selection;

3850

iface->get_run_attributes = eel_editable_label_accessible_get_run_attributes;

3851

iface->get_default_attributes = eel_editable_label_accessible_get_default_attributes;

3852

iface->get_character_extents = eel_editable_label_accessible_get_character_extents;

3853

iface->get_offset_at_point = eel_editable_label_accessible_get_offset_at_point;

3854

}

3855

3856

static void

3857

eel_editable_label_accessible_set_text_contents (AtkEditableText *text,

3858

const gchar *string)

3859

{

3860

CtkWidget *widget;

3861

EelEditableLabel *label;

3862

3863

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3864

if (widget == NULL((void*)0))

3865

/* State is defunct */

3866

return;

3867

3868

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3869

3870

eel_editable_label_set_text (label, string);

3871

}

3872

3873

static void

3874

eel_editable_label_accessible_insert_text (AtkEditableText *text,

3875

const gchar *string,

3876

gint length,

3877

gint *position)

3878

{

3879

CtkWidget *widget;

3880

EelEditableLabel *label;

3881

CtkEditable *editable;

3882

3883

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3884

if (widget == NULL((void*)0))

3885

/* State is defunct */

3886

return;

3887

3888

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3889

editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

3890

3891

ctk_editable_insert_text (editable, string, length, position);

3892

}

3893

3894

static void

3895

eel_editable_label_accessible_copy_text (AtkEditableText *text,

3896

gint start_pos,

3897

gint end_pos)

3898

{

3899

CtkWidget *widget;

3900

EelEditableLabel *label;

3901

CtkEditable *editable;

3902

gchar *str;

3903

3904

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3905

if (widget == NULL((void*)0))

3906

/* State is defunct */

3907

return;

3908

3909

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3910

editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

3911

str = ctk_editable_get_chars (editable, start_pos, end_pos);

3912

ctk_clipboard_set_text (ctk_clipboard_get (CDK_NONE((CdkAtom)((gpointer) (gulong) (0)))), str, -1);

3913

}

3914

3915

static void

3916

eel_editable_label_accessible_cut_text (AtkEditableText *text,

3917

gint start_pos,

3918

gint end_pos)

3919

{

3920

CtkWidget *widget;

3921

EelEditableLabel *label;

3922

CtkEditable *editable;

3923

gchar *str;

3924

3925

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3926

if (widget == NULL((void*)0))

3927

/* State is defunct */

3928

return;

3929

3930

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3931

editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

3932

str = ctk_editable_get_chars (editable, start_pos, end_pos);

3933

ctk_clipboard_set_text (ctk_clipboard_get (CDK_NONE((CdkAtom)((gpointer) (gulong) (0)))), str, -1);

3934

ctk_editable_delete_text (editable, start_pos, end_pos);

3935

}

3936

3937

static void

3938

eel_editable_label_accessible_delete_text (AtkEditableText *text,

3939

gint start_pos,

3940

gint end_pos)

3941

{

3942

CtkWidget *widget;

3943

EelEditableLabel *label;

3944

CtkEditable *editable;

3945

3946

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3947

if (widget == NULL((void*)0))

3948

/* State is defunct */

3949

return;

3950

3951

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3952

editable = CTK_EDITABLE (label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_editable_get_type ()))))));

3953

3954

ctk_editable_delete_text (editable, start_pos, end_pos);

3955

}

3956

3957

static void

3958

eel_editable_label_accessible_paste_received (CtkClipboard *clipboard G_GNUC_UNUSED__attribute__ ((__unused__)),

3959

const gchar *text,

3960

gpointer data)

3961

{

3962

EelEditableLabelAccessiblePaste* paste_struct = (EelEditableLabelAccessiblePaste *)data;

3963

3964

if (text)

3965

ctk_editable_insert_text (CTK_EDITABLE (paste_struct->label)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((paste_struct->label)), ((ctk_editable_get_type ()))))
)), text, -1,

3966

&(paste_struct->position));

3967

3968

g_object_unref (paste_struct->label);

3969

}

3970

3971

static void

3972

eel_editable_label_accessible_paste_text (AtkEditableText *text,

3973

gint position)

3974

{

3975

CtkWidget *widget;

3976

CtkEditable *editable;

3977

EelEditableLabelAccessiblePaste paste_struct;

3978

3979

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (text)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((text)), ((ctk_accessible_get_type ())))))));

3980

if (widget == NULL((void*)0))

3981

/* State is defunct */

3982

return;

3983

3984

editable = CTK_EDITABLE (widget)((((CtkEditable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_editable_get_type ()))))));

3985

if (!ctk_editable_get_editable (editable))

3986

return;

3987

paste_struct.label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

3988

paste_struct.position = position;

3989

3990

g_object_ref (paste_struct.label)((__typeof__ (paste_struct.label)) (g_object_ref) (paste_struct
.label));

3991

ctk_clipboard_request_text (ctk_clipboard_get (CDK_NONE((CdkAtom)((gpointer) (gulong) (0)))),

3992

eel_editable_label_accessible_paste_received, &paste_struct);

3993

}

3994

3995

static void

3996

atk_editable_text_interface_init (AtkEditableTextIface *iface)

3997

{

3998

g_assert (iface != NULL)do { if (iface != ((void*)0)) ; else g_assertion_message_expr
("Eel", "eel-editable-label.c", 3998, ((const char*) (__func__
)), "iface != NULL"); } while (0);

3999

4000

iface->set_text_contents = eel_editable_label_accessible_set_text_contents;

4001

iface->insert_text = eel_editable_label_accessible_insert_text;

4002

iface->copy_text = eel_editable_label_accessible_copy_text;

4003

iface->cut_text = eel_editable_label_accessible_cut_text;

4004

iface->delete_text = eel_editable_label_accessible_delete_text;

4005

iface->paste_text = eel_editable_label_accessible_paste_text;

4006

}

4007

4008

static void

4009

eel_editable_label_accessible_notify_insert (AtkObject *accessible)

4010

{

4011

EelEditableLabelAccessiblePrivate *priv;

4012

4013

priv = g_object_get_data (G_OBJECT (accessible)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

4014

if (priv->signal_name)

4015

{

4016

g_signal_emit_by_name (accessible,

4017

priv->signal_name,

4018

priv->position,

4019

priv->length);

4020

priv->signal_name = NULL((void*)0);

4021

}

4022

}

4023

4024

static gboolean

4025

eel_editable_label_accessible_idle_notify_insert (gpointer data)

4026

{

4027

eel_editable_label_accessible_notify_insert (data);

4028

return FALSE(0);

4029

}

4030

4031

/* Note arg1 returns the character at the start of the insert.

4032

* arg2 returns the number of characters inserted.

4033

*/

4034

static void

4035

eel_editable_label_accessible_insert_text_cb (EelEditableLabel *label,

4036

gchar *arg1 G_GNUC_UNUSED__attribute__ ((__unused__)),

4037

gint arg2,

4038

gpointer arg3)

4039

{

4040

AtkObject *accessible;

4041

EelEditableLabelAccessiblePrivate *priv;

4042

gint *position = (gint *) arg3;

4043

4044

accessible = ctk_widget_get_accessible (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

4045

priv = g_object_get_data (G_OBJECT (accessible)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

4046

if (!priv->signal_name)

4047

{

4048

priv->signal_name = "text_changed::insert";

4049

priv->position = *position;

4050

priv->length = arg2;

4051

}

4052

/*

4053

* The signal will be emitted when the cursor position is updated.

4054

* or in an idle handler if it not updated.

4055

*/

4056

g_idle_add (eel_editable_label_accessible_idle_notify_insert, accessible);

4057

}

4058

4059

/* Note arg1 returns the start of the delete range, arg2 returns the

4060

* end of the delete range if multiple characters are deleted.

4061

*/

4062

static void

4063

eel_editable_label_accessible_delete_text_cb (EelEditableLabel *label,

4064

gint arg1,

4065

gint arg2)

4066

{

4067

AtkObject *accessible;

4068

4069

accessible = ctk_widget_get_accessible (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

4070

4071

/*

4072

* Zero length text deleted so ignore

4073

*/

4074

if (arg2 - arg1 == 0)

4075

return;

4076

4077

g_signal_emit_by_name (accessible, "text_changed::delete", arg1, arg2 - arg1);

4078

}

4079

4080

static void

4081

eel_editable_label_accessible_changed_cb (EelEditableLabel *label)

4082

{

4083

AtkObject *accessible;

4084

EelEditableLabelAccessiblePrivate *priv;

4085

4086

accessible = ctk_widget_get_accessible (CTK_WIDGET (label)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label)), ((ctk_widget_get_type ())))))));

4087

priv = g_object_get_data (G_OBJECT (accessible)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

4088

cail_text_util_text_setup (priv->textutil, eel_editable_label_get_text (label));

4089

}

4090

4091

static gboolean

4092

check_for_selection_change (AtkObject *accessible,

4093

CtkWidget *widget)

4094

{

4095

EelEditableLabelAccessiblePrivate *priv;

4096

EelEditableLabel *label;

4097

gboolean ret_val = FALSE(0);

4098

4099

priv = g_object_get_data (G_OBJECT (accessible)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data);

4100

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

4101

4102

if (label->selection_anchor != label->selection_end)

4103

{

4104

if (label->selection_anchor != priv->selection_anchor ||

4105

label->selection_end != priv->selection_end)

4106

/*

4107

* This check is here as this function can be called

4108

* for notification of selection_end and selection_anchor.

4109

* The values of selection_anchor and selection_end may be the same

4110

* for both notifications and we only want to generate one

4111

* text_selection_changed signal.

4112

*/

4113

ret_val = TRUE(!(0));

4114

}

4115

else

4116

{

4117

/* We had a selection */

4118

ret_val = (priv->selection_anchor != priv->selection_end);

4119

}

4120

priv->selection_anchor = label->selection_anchor;

4121

priv->selection_end = label->selection_end;

4122

4123

return ret_val;

4124

}

4125

4126

static void

4127

eel_editable_label_accessible_notify_ctk (GObject *obj,

4128

GParamSpec *pspec)

4129

{

4130

CtkWidget *widget;

4131

AtkObject *accessible;

4132

EelEditableLabel *label;

4133

4134

widget = CTK_WIDGET (obj)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((obj)), ((ctk_widget_get_type ()))))));

4135

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

4136

accessible = ctk_widget_get_accessible (widget);

4137

4138

if (strcmp (pspec->name, "cursor-position") == 0)

4139

{

4140

eel_editable_label_accessible_notify_insert (accessible);

4141

if (check_for_selection_change (accessible, widget))

4142

g_signal_emit_by_name (accessible, "text_selection_changed");

4143

/*

4144

* The label cursor position has moved so generate the signal.

4145

*/

4146

g_signal_emit_by_name (accessible, "text_caret_moved",

4147

g_utf8_pointer_to_offset (label->text,

4148

label->text + label->selection_anchor));

4149

}

4150

else if (strcmp (pspec->name, "selection-bound") == 0)

4151

{

4152

eel_editable_label_accessible_notify_insert (accessible);

4153

4154

if (check_for_selection_change (accessible, widget))

4155

g_signal_emit_by_name (accessible, "text_selection_changed");

4156

}

4157

}

4158

4159

static void

4160

eel_editable_label_accessible_initialize (AtkObject *accessible,

4161

gpointer widget)

4162

{

4163

EelEditableLabelAccessiblePrivate *priv;

4164

EelEditableLabel *label;

4165

4166

a11y_parent_class->initialize (accessible, widget);

4167

4168

label = EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
));

4169

priv = g_new0 (EelEditableLabelAccessiblePrivate, 1)((EelEditableLabelAccessiblePrivate *) g_malloc0_n ((1), sizeof
(EelEditableLabelAccessiblePrivate)));

4170

priv->textutil = cail_text_util_new ();

4171

cail_text_util_text_setup (priv->textutil, eel_editable_label_get_text (EEL_EDITABLE_LABEL (widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
))));

4172

priv->selection_anchor = label->selection_anchor;

4173

priv->selection_end = label->selection_end;

4174

g_object_set_data (G_OBJECT (accessible)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), (((GType) ((20) << (2)))))))), eel_editable_label_accessible_data, priv);

4175

g_signal_connect (widget, "insert-text",g_signal_connect_data ((widget), ("insert-text"), (((GCallback
) (eel_editable_label_accessible_insert_text_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0)

4176

G_CALLBACK (eel_editable_label_accessible_insert_text_cb), NULL)g_signal_connect_data ((widget), ("insert-text"), (((GCallback
) (eel_editable_label_accessible_insert_text_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0);

4177

g_signal_connect (widget, "delete-text",g_signal_connect_data ((widget), ("delete-text"), (((GCallback
) (eel_editable_label_accessible_delete_text_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0)

4178

G_CALLBACK (eel_editable_label_accessible_delete_text_cb), NULL)g_signal_connect_data ((widget), ("delete-text"), (((GCallback
) (eel_editable_label_accessible_delete_text_cb))), (((void*)
0)), ((void*)0), (GConnectFlags) 0);

4179

g_signal_connect (widget, "changed",g_signal_connect_data ((widget), ("changed"), (((GCallback) (
eel_editable_label_accessible_changed_cb))), (((void*)0)), ((
void*)0), (GConnectFlags) 0)

4180

G_CALLBACK (eel_editable_label_accessible_changed_cb), NULL)g_signal_connect_data ((widget), ("changed"), (((GCallback) (
eel_editable_label_accessible_changed_cb))), (((void*)0)), ((
void*)0), (GConnectFlags) 0);

4181

4182

g_signal_connect (widget,g_signal_connect_data ((widget), ("notify"), (((GCallback) (eel_editable_label_accessible_notify_ctk
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)

4183

"notify",g_signal_connect_data ((widget), ("notify"), (((GCallback) (eel_editable_label_accessible_notify_ctk
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)

4184

G_CALLBACK (eel_editable_label_accessible_notify_ctk),g_signal_connect_data ((widget), ("notify"), (((GCallback) (eel_editable_label_accessible_notify_ctk
))), (((void*)0)), ((void*)0), (GConnectFlags) 0)

4185

NULL)g_signal_connect_data ((widget), ("notify"), (((GCallback) (eel_editable_label_accessible_notify_ctk
))), (((void*)0)), ((void*)0), (GConnectFlags) 0);

4186

atk_object_set_role (accessible, ATK_ROLE_TEXT);

4187

}

4188

4189

static const gchar* eel_editable_label_accessible_get_name(AtkObject* accessible)

4190

{

4191

if (accessible->name != NULL((void*)0))

4192

{

4193

return accessible->name;

4194

}

4195

else

4196

{

4197

CtkWidget* widget;

4198

4199

widget = ctk_accessible_get_widget(CTK_ACCESSIBLE(accessible)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), ((ctk_accessible_get_type ())))))));

4200

4201

if (widget == NULL((void*)0))

4202

{

4203

/* State is defunct */

4204

return NULL((void*)0);

4205

}

4206

4207

g_assert(EEL_IS_EDITABLE_LABEL(widget))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((widget)); GType __t = (eel_editable_label_get_type()); gboolean
__r; if (!__inst) __r = (0); else if (__inst->g_class &&
__inst->g_class->g_type == __t) __r = (!(0)); else __r
= g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else
g_assertion_message_expr ("Eel", "eel-editable-label.c", 4207
, ((const char*) (__func__)), "EEL_IS_EDITABLE_LABEL(widget)"
); } while (0);

4208

4209

return eel_editable_label_get_text(EEL_EDITABLE_LABEL(widget)((((EelEditableLabel*) (void *) g_type_check_instance_cast ((
GTypeInstance*) ((widget)), (eel_editable_label_get_type())))
)));

4210

}

4211

}

4212

4213

static AtkStateSet*

4214

eel_editable_label_accessible_ref_state_set (AtkObject *accessible)

4215

{

4216

AtkStateSet *state_set;

4217

CtkWidget *widget;

4218

4219

state_set = a11y_parent_class->ref_state_set (accessible);

4220

widget = ctk_accessible_get_widget (CTK_ACCESSIBLE (accessible)((((CtkAccessible*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((accessible)), ((ctk_accessible_get_type ())))))));

4221

4222

if (widget == NULL((void*)0))

4223

return state_set;

4224

4225

atk_state_set_add_state (state_set, ATK_STATE_EDITABLE);

4226

atk_state_set_add_state (state_set, ATK_STATE_MULTI_LINE);

4227

return state_set;

4228

}

4229

4230

static void

4231

eel_editable_label_accessible_finalize (GObject *object)

4232

{

4233

EelEditableLabelAccessiblePrivate *priv;

4234

4235

priv = g_object_get_data (object, eel_editable_label_accessible_data);

4236

g_object_unref (priv->textutil);

4237

g_free (priv);

4238

G_OBJECT_CLASS (a11y_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((a11y_parent_class)), (((GType) ((20) << (2))))))))->finalize (object);

4239

}

4240

4241

G_DEFINE_TYPE_WITH_CODE (EelEditableLabelAccessible,static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4242

eel_editable_label_accessible,static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4243

CTK_TYPE_WIDGET_ACCESSIBLE,static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4244

G_IMPLEMENT_INTERFACE (ATK_TYPE_EDITABLE_TEXT,static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4245

atk_editable_text_interface_init)static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4246

G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT,static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; }

4247

atk_text_interface_init))static void eel_editable_label_accessible_init (EelEditableLabelAccessible
*self); static void eel_editable_label_accessible_class_init
(EelEditableLabelAccessibleClass *klass); static GType eel_editable_label_accessible_get_type_once
(void); static gpointer eel_editable_label_accessible_parent_class
= ((void*)0); static gint EelEditableLabelAccessible_private_offset
; static void eel_editable_label_accessible_class_intern_init
(gpointer klass) { eel_editable_label_accessible_parent_class
= g_type_class_peek_parent (klass); if (EelEditableLabelAccessible_private_offset
!= 0) g_type_class_adjust_private_offset (klass, &EelEditableLabelAccessible_private_offset
); eel_editable_label_accessible_class_init ((EelEditableLabelAccessibleClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
eel_editable_label_accessible_get_instance_private (EelEditableLabelAccessible
*self) { return (((gpointer) ((guint8*) (self) + (glong) (EelEditableLabelAccessible_private_offset
)))); } GType eel_editable_label_accessible_get_type (void) {
static GType static_g_define_type_id = 0; if ((__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); (void) (
0 ? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
(*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
= eel_editable_label_accessible_get_type_once (); (__extension__
({ _Static_assert (sizeof *(&static_g_define_type_id) ==
sizeof (gpointer), "Expression evaluates to false"); 0 ? (void
) (*(&static_g_define_type_id) = (g_define_type_id)) : (void
) 0; g_once_init_leave_pointer ((&static_g_define_type_id
), (gpointer) (guintptr) (g_define_type_id)); })) ; } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType eel_editable_label_accessible_get_type_once
(void) { GType g_define_type_id = g_type_register_static_simple
((ctk_widget_accessible_get_type ()), g_intern_static_string
("EelEditableLabelAccessible"), sizeof (EelEditableLabelAccessibleClass
), (GClassInitFunc)(void (*)(void)) eel_editable_label_accessible_class_intern_init
, sizeof (EelEditableLabelAccessible), (GInstanceInitFunc)(void
(*)(void)) eel_editable_label_accessible_init, (GTypeFlags) 0
); { {{ const GInterfaceInfo g_implement_interface_info = { (
GInterfaceInitFunc)(void (*)(void)) atk_editable_text_interface_init
, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id
, (atk_editable_text_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) atk_text_interface_init, ((void*)0), ((void
*)0) }; g_type_add_interface_static (g_define_type_id, (atk_text_get_type
()), &g_implement_interface_info); };} } return g_define_type_id
; };

4248

4249

static void

4250

eel_editable_label_accessible_class_init (EelEditableLabelAccessibleClass *klass)

4251

{

4252

AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass)((((AtkObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), ((atk_object_get_type ()))))));

4253

GObjectClass *gobject_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((klass)), (((GType) ((20) << (2))))))));

4254

4255

a11y_parent_class = g_type_class_peek_parent (klass);

4256

4257

atk_class->initialize = eel_editable_label_accessible_initialize;

4258

atk_class->get_name = eel_editable_label_accessible_get_name;

4259

atk_class->ref_state_set = eel_editable_label_accessible_ref_state_set;

4260

gobject_class->finalize = eel_editable_label_accessible_finalize;

4261

}

4262

4263

static void

4264

eel_editable_label_accessible_init (EelEditableLabelAccessible *accessible G_GNUC_UNUSED__attribute__ ((__unused__)))

4265

{

4266

}

File:	eel/eel-editable-label.c
Warning:	line 2795, column 13 This statement is never executed

Bug Summary

Annotated Source Code