~smspillaz/xig/xig.disconnect-signals : revision 237

1

/*

2

3

*

4

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

5

* the terms of the GNU Lesser General Public License version 3 as published by

6

* the Free Software Foundation. See http://www.gnu.org/copyleft/lgpl.html the

7

* full text of the license.

8

*/

9

10

#include <string.h>

11

12

#include "xig/xig-codec.h"

13

14

G_DEFINE_TYPE (XigCodec, xig_codec, G_TYPE_OBJECT);

15

16

enum

17

{

18

CONNECT,

19

FAILED,

20

AUTHENTICATE,

21

SUCCESS,

22

ERROR,

23

KEY_PRESS,

24

BUTTON_PRESS,

25

MOTION_NOTIFY,

26

ENTER_NOTIFY,

27

FOCUS_IN,

28

KEYMAP_NOTIFY,

29

EXPOSE,

30

GRAPHICS_EXPOSURE,

31

NO_EXPOSURE,

32

VISIBILITY_NOTIFY,

33

CREATE_NOTIFY,

34

DESTROY_NOTIFY,

35

UNMAP_NOTIFY,

36

MAP_NOTIFY,

37

MAP_REQUEST,

38

REPARENT_NOTIFY,

39

CONFIGURE_NOTIFY,

40

CONFIGURE_REQUEST,

41

GRAVITY_NOTIFY,

42

RESIZE_REQUEST,

43

CIRCULATE_NOTIFY,

44

CIRCULATE_REQUEST,

45

PROPERTY_NOTIFY,

46

SELECTION_CLEAR,

47

SELECTION_REQUEST,

48

SELECTION_NOTIFY,

49

COLORMAP_NOTIFY,

50

CLIENT_MESSAGE,

51

MAPPING_NOTIFY,

52

CREATE_WINDOW,

53

CHANGE_WINDOW_ATTRIBUTES,

54

GET_WINDOW_ATTRIBUTES,

55

GET_WINDOW_ATTRIBUTES_REPLY,

56

DESTROY_WINDOW,

57

DESTROY_SUBWINDOWS,

58

CHANGE_SAVE_SET,

59

REPARENT_WINDOW,

60

MAP_WINDOW,

61

MAP_SUBWINDOWS,

62

UNMAP_WINDOW,

63

UNMAP_SUBWINDOWS,

64

CONFIGURE_WINDOW,

65

CIRCULATE_WINDOW,

66

GET_GEOMETRY,

67

GET_GEOMETRY_REPLY,

68

QUERY_TREE,

69

QUERY_TREE_REPLY,

70

INTERN_ATOM,

71

INTERN_ATOM_REPLY,

72

GET_ATOM_NAME,

73

GET_ATOM_NAME_REPLY,

74

CHANGE_PROPERTY,

75

DELETE_PROPERTY,

76

GET_PROPERTY,

77

GET_PROPERTY_REPLY,

78

LIST_PROPERTIES,

79

LIST_PROPERTIES_REPLY,

80

SET_SELECTION_OWNER,

81

GET_SELECTION_OWNER,

82

GET_SELECTION_OWNER_REPLY,

83

CONVERT_SELECTION,

84

SEND_EVENT,

85

GRAB_POINTER,

86

GRAB_POINTER_REPLY,

87

UNGRAB_POINTER,

88

GRAB_BUTTON,

89

UNGRAB_BUTTON,

90

CHANGE_ACTIVE_POINTER_GRAB,

91

GRAB_KEYBOARD,

92

GRAB_KEYBOARD_REPLY,

93

UNGRAB_KEYBOARD,

94

GRAB_KEY,

95

UNGRAB_KEY,

96

ALLOW_EVENTS,

97

GRAB_SERVER,

98

UNGRAB_SERVER,

99

QUERY_POINTER,

100

QUERY_POINTER_REPLY,

101

GET_MOTION_EVENTS,

102

GET_MOTION_EVENTS_REPLY,

103

TRANSLATE_COORDINATES,

104

TRANSLATE_COORDINATES_REPLY,

105

WARP_POINTER,

106

SET_INPUT_FOCUS,

107

GET_INPUT_FOCUS,

108

GET_INPUT_FOCUS_REPLY,

109

QUERY_KEYMAP,

110

QUERY_KEYMAP_REPLY,

111

OPEN_FONT,

112

CLOSE_FONT,

113

QUERY_FONT,

114

QUERY_FONT_REPLY,

115

QUERY_TEXT_EXTENTS,

116

QUERY_TEXT_EXTENTS_REPLY,

117

LIST_FONTS,

118

LIST_FONTS_REPLY,

119

LIST_FONTS_WITH_INFO,

120

LIST_FONTS_WITH_INFO_REPLY,

121

SET_FONT_PATH,

122

GET_FONT_PATH,

123

GET_FONT_PATH_REPLY,

124

CREATE_PIXMAP,

125

FREE_PIXMAP,

126

CREATE_GC,

127

CHANGE_GC,

128

COPY_GC,

129

SET_DASHES,

130

SET_CLIP_RECTANGLES,

131

FREE_GC,

132

CLEAR_AREA,

133

COPY_AREA,

134

COPY_PLANE,

135

POLY_POINT,

136

POLY_LINE,

137

POLY_SEGMENT,

138

POLY_RECTANGLE,

139

POLY_ARC,

140

FILL_POLY,

141

POLY_FILL_RECTANGLE,

142

POLY_FILL_ARC,

143

PUT_IMAGE,

144

GET_IMAGE,

145

GET_IMAGE_REPLY,

146

POLY_TEXT8,

147

POLY_TEXT16,

148

IMAGE_TEXT8,

149

IMAGE_TEXT16,

150

CREATE_COLORMAP,

151

FREE_COLORMAP,

152

COPY_COLORMAP_AND_FREE,

153

INSTALL_COLORMAP,

154

UNINSTALL_COLORMAP,

155

LIST_INSTALLED_COLORMAPS,

156

LIST_INSTALLED_COLORMAPS_REPLY,

157

ALLOC_COLOR,

158

ALLOC_COLOR_REPLY,

159

ALLOC_NAMED_COLOR,

160

ALLOC_NAMED_COLOR_REPLY,

161

ALLOC_COLOR_CELLS,

162

ALLOC_COLOR_CELLS_REPLY,

163

ALLOC_COLOR_PLANES,

164

ALLOC_COLOR_PLANES_REPLY,

165

FREE_COLORS,

166

STORE_COLORS,

167

STORE_NAMED_COLOR,

168

QUERY_COLORS,

169

QUERY_COLORS_REPLY,

170

LOOKUP_COLOR,

171

LOOKUP_COLOR_REPLY,

172

CREATE_CURSOR,

173

CREATE_GLYPH_CURSOR,

174

FREE_CURSOR,

175

RECOLOR_CURSOR,

176

QUERY_BEST_SIZE,

177

QUERY_BEST_SIZE_REPLY,

178

QUERY_EXTENSION,

179

QUERY_EXTENSION_REPLY,

180

LIST_EXTENSIONS,

181

LIST_EXTENSIONS_REPLY,

182

CHANGE_KEYBOARD_MAPPING,

183

GET_KEYBOARD_MAPPING,

184

GET_KEYBOARD_MAPPING_REPLY,

185

CHANGE_KEYBOARD_CONTROL,

186

GET_KEYBOARD_CONTROL,

187

GET_KEYBOARD_CONTROL_REPLY,

188

BELL,

189

CHANGE_POINTER_CONTROL,

190

GET_POINTER_CONTROL,

191

GET_POINTER_CONTROL_REPLY,

192

SET_SCREEN_SAVER,

193

GET_SCREEN_SAVER,

194

GET_SCREEN_SAVER_REPLY,

195

CHANGE_HOSTS,

196

LIST_HOSTS,

197

LIST_HOSTS_REPLY,

198

SET_ACCESS_CONTROL,

199

SET_CLOSE_DOWN_MODE,

200

KILL_CLIENT,

201

ROTATE_PROPERTIES,

202

FORCE_SCREEN_SAVER,

203

SET_POINTER_MAPPING,

204

SET_POINTER_MAPPING_REPLY,

205

GET_POINTER_MAPPING,

206

GET_POINTER_MAPPING_REPLY,

207

SET_MODIFIER_MAPPING,

208

SET_MODIFIER_MAPPING_REPLY,

209

GET_MODIFIER_MAPPING,

210

GET_MODIFIER_MAPPING_REPLY,

211

NO_OPERATION,

212

BIGREQ_ENABLE,

213

BIGREQ_ENABLE_REPLY,

214

SYNC_COUNTER_NOTIFY,

215

SYNC_ALARM_NOTIFY,

216

SYNC_INITIALIZE,

217

SYNC_INITIALIZE_REPLY,

218

SYNC_LIST_SYSTEM_COUNTERS,

219

SYNC_LIST_SYSTEM_COUNTERS_REPLY,

220

SYNC_CREATE_COUNTER,

221

SYNC_DESTROY_COUNTER,

222

SYNC_QUERY_COUNTER,

223

SYNC_QUERY_COUNTER_REPLY,

224

SYNC_AWAIT,

225

SYNC_CHANGE_COUNTER,

226

SYNC_SET_COUNTER,

227

SYNC_CREATE_ALARM,

228

SYNC_CHANGE_ALARM,

229

SYNC_DESTROY_ALARM,

230

SYNC_QUERY_ALARM,

231

SYNC_QUERY_ALARM_REPLY,

232

SYNC_SET_PRIORITY,

233

SYNC_GET_PRIORITY,

234

SYNC_GET_PRIORITY_REPLY,

235

SYNC_CREATE_FENCE,

236

SYNC_TRIGGER_FENCE,

237

SYNC_RESET_FENCE,

238

SYNC_DESTROY_FENCE,

239

SYNC_QUERY_FENCE,

240

SYNC_QUERY_FENCE_REPLY,

241

SYNC_AWAIT_FENCE,

242

RANDR_SCREEN_CHANGE_NOTIFY,

243

RANDR_NOTIFY,

244

RANDR_QUERY_VERSION,

245

RANDR_QUERY_VERSION_REPLY,

246

RANDR_SET_SCREEN_CONFIG,

247

RANDR_SET_SCREEN_CONFIG_REPLY,

248

RANDR_SELECT_INPUT,

249

RANDR_GET_SCREEN_INFO,

250

RANDR_GET_SCREEN_INFO_REPLY,

251

RANDR_GET_SCREEN_SIZE_RANGE,

252

RANDR_GET_SCREEN_SIZE_RANGE_REPLY,

253

RANDR_SET_SCREEN_SIZE,

254

RANDR_GET_SCREEN_RESOURCES,

255

RANDR_GET_SCREEN_RESOURCES_REPLY,

256

RANDR_GET_OUTPUT_INFO,

257

RANDR_GET_OUTPUT_INFO_REPLY,

258

RANDR_LIST_OUTPUT_PROPERTIES,

259

RANDR_LIST_OUTPUT_PROPERTIES_REPLY,

260

RANDR_QUERY_OUTPUT_PROPERTY,

261

RANDR_QUERY_OUTPUT_PROPERTY_REPLY,

262

RANDR_CONFIGURE_OUTPUT_PROPERTY,

263

RANDR_CHANGE_OUTPUT_PROPERTY,

264

RANDR_DELETE_OUTPUT_PROPERTY,

265

RANDR_GET_OUTPUT_PROPERTY,

266

RANDR_GET_OUTPUT_PROPERTY_REPLY,

267

RANDR_CREATE_MODE,

268

RANDR_CREATE_MODE_REPLY,

269

RANDR_DESTROY_MODE,

270

RANDR_ADD_OUTPUT_MODE,

271

RANDR_DELETE_OUTPUT_MODE,

272

RANDR_GET_CRTC_INFO,

273

RANDR_GET_CRTC_INFO_REPLY,

274

RANDR_SET_CRTC_CONFIG,

275

RANDR_SET_CRTC_CONFIG_REPLY,

276

RANDR_GET_CRTC_GAMMA_SIZE,

277

RANDR_GET_CRTC_GAMMA_SIZE_REPLY,

278

RANDR_GET_CRTC_GAMMA,

279

RANDR_GET_CRTC_GAMMA_REPLY,

280

RANDR_SET_CRTC_GAMMA,

281

RANDR_GET_SCREEN_RESOURCES_CURRENT,

282

RANDR_GET_SCREEN_RESOURCES_CURRENT_REPLY,

283

RANDR_SET_CRTC_TRANSFORM,

284

RANDR_GET_CRTC_TRANSFORM,

285

RANDR_GET_CRTC_TRANSFORM_REPLY,

286

RANDR_GET_PANNING,

287

RANDR_GET_PANNING_REPLY,

288

RANDR_SET_PANNING,

289

RANDR_SET_PANNING_REPLY,

290

RANDR_SET_OUTPUT_PRIMARY,

291

RANDR_GET_OUTPUT_PRIMARY,

292

RANDR_GET_OUTPUT_PRIMARY_REPLY,

293

XINERAMA_QUERY_VERSION,

294

XINERAMA_QUERY_VERSION_REPLY,

295

XINERAMA_GET_STATE,

296

XINERAMA_GET_STATE_REPLY,

297

XINERAMA_GET_SCREEN_COUNT,

298

XINERAMA_GET_SCREEN_COUNT_REPLY,

299

XINERAMA_GET_SCREEN_SIZE,

300

XINERAMA_GET_SCREEN_SIZE_REPLY,

301

XINERAMA_IS_ACTIVE,

302

XINERAMA_IS_ACTIVE_REPLY,

303

XINERAMA_QUERY_SCREENS,

304

XINERAMA_QUERY_SCREENS_REPLY,

305

XKB_NEW_KEYBOARD_NOTIFY,

306

XKB_MAP_NOTIFY,

307

XKB_STATE_NOTIFY,

308

XKB_CONTROLS_NOTIFY,

309

XKB_INDICATOR_STATE_NOTIFY,

310

XKB_INDICATOR_MAP_NOTIFY,

311

XKB_NAMES_NOTIFY,

312

XKB_COMPAT_MAP_NOTIFY,

313

XKB_BELL_NOTIFY,

314

XKB_ACTION_MESSAGE,

315

XKB_ACCESS_XNOTIFY,

316

XKB_EXTENSION_DEVICE_NOTIFY,

317

XKB_USE_EXTENSION,

318

XKB_USE_EXTENSION_REPLY,

319

XKB_SELECT_EVENTS,

320

XKB_BELL,

321

XKB_GET_STATE,

322

XKB_GET_STATE_REPLY,

323

XKB_LATCH_LOCK_STATE,

324

XKB_GET_CONTROLS,

325

XKB_GET_CONTROLS_REPLY,

326

XKB_SET_CONTROLS,

327

XKB_GET_MAP,

328

XKB_GET_MAP_REPLY,

329

XKB_SET_MAP,

330

XKB_GET_COMPAT_MAP,

331

XKB_GET_COMPAT_MAP_REPLY,

332

XKB_SET_COMPAT_MAP,

333

XKB_GET_INDICATOR_STATE,

334

XKB_GET_INDICATOR_STATE_REPLY,

335

XKB_GET_INDICATOR_MAP,

336

XKB_GET_INDICATOR_MAP_REPLY,

337

XKB_SET_INDICATOR_MAP,

338

XKB_GET_NAMED_INDICATOR,

339

XKB_GET_NAMED_INDICATOR_REPLY,

340

XKB_SET_NAMED_INDICATOR,

341

XKB_GET_NAMES,

342

XKB_GET_NAMES_REPLY,

343

XKB_SET_NAMES,

344

XKB_GET_GEOMETRY,

345

XKB_GET_GEOMETRY_REPLY,

346

XKB_SET_GEOMETRY,

347

XKB_PER_CLIENT_FLAGS,

348

XKB_PER_CLIENT_FLAGS_REPLY,

349

XKB_LIST_COMPONENTS,

350

XKB_LIST_COMPONENTS_REPLY,

351

XKB_GET_KBD_BY_NAME,

352

XKB_GET_KBD_BY_NAME_REPLY,

353

XKB_GET_DEVICE_INFO,

354

XKB_GET_DEVICE_INFO_REPLY,

355

XKB_SET_DEVICE_INFO,

356

XKB_SET_DEBUGGING_FLAGS,

357

XKB_SET_DEBUGGING_FLAGS_REPLY,

358

RENDER_QUERY_VERSION,

359

RENDER_QUERY_VERSION_REPLY,

360

RENDER_QUERY_PICT_FORMATS,

361

RENDER_QUERY_PICT_FORMATS_REPLY,

362

RENDER_QUERY_PICT_INDEX_VALUES,

363

RENDER_QUERY_PICT_INDEX_VALUES_REPLY,

364

RENDER_CREATE_PICTURE,

365

RENDER_CHANGE_PICTURE,

366

RENDER_SET_PICTURE_CLIP_RECTANGLES,

367

RENDER_FREE_PICTURE,

368

RENDER_COMPOSITE,

369

RENDER_TRAPEZOIDS,

370

RENDER_TRIANGLES,

371

RENDER_TRI_STRIP,

372

RENDER_TRI_FAN,

373

RENDER_CREATE_GLYPH_SET,

374

RENDER_REFERENCE_GLYPH_SET,

375

RENDER_FREE_GLYPH_SET,

376

RENDER_ADD_GLYPHS,

377

RENDER_FREE_GLYPHS,

378

RENDER_COMPOSITE_GLYPHS8,

379

RENDER_COMPOSITE_GLYPHS16,

380

RENDER_COMPOSITE_GLYPHS32,

381

RENDER_FILL_RECTANGLES,

382

RENDER_CREATE_CURSOR,

383

RENDER_SET_PICTURE_TRANSFORM,

384

RENDER_QUERY_FILTERS,

385

RENDER_QUERY_FILTERS_REPLY,

386

RENDER_SET_PICTURE_FILTER,

387

RENDER_CREATE_ANIM_CURSOR,

388

RENDER_ADD_TRAPS,

389

RENDER_CREATE_SOLID_FILL,

390

RENDER_CREATE_LINEAR_GRADIENT,

391

RENDER_CREATE_RADIAL_GRADIENT,

392

RENDER_CREATE_CONICAL_GRADIENT,

393

LAST_SIGNAL

394

};

395

static guint signals[LAST_SIGNAL] = { 0 };

396

397

XigCodec *

398

xig_codec_new (void)

399

{

400

return g_object_new (xig_codec_get_type (), NULL);

401

}

402

403

void

404

xig_codec_feed_data (XigCodec *codec, const guint8 *data, gsize data_length)

405

{

406

XIG_CODEC_GET_CLASS (codec)->feed_data (codec, data, data_length);

407

}

408

409

void

410

xig_codec_feed_connect (XigCodec *codec, XigConnect *message)

411

{

412

g_signal_emit (codec, signals[CONNECT], 0, message);

413

}

414

415

void

416

xig_codec_feed_failed (XigCodec *codec, XigFailed *message)

417

{

418

g_signal_emit (codec, signals[FAILED], 0, message);

419

}

420

421

void

422

xig_codec_feed_authenticate (XigCodec *codec, XigAuthenticate *message)

423

{

424

g_signal_emit (codec, signals[AUTHENTICATE], 0, message);

425

}

426

427

void

428

xig_codec_feed_success (XigCodec *codec, XigSuccess *message)

429

{

430

g_signal_emit (codec, signals[SUCCESS], 0, message);

431

}

432

433

void

434

xig_codec_feed_error (XigCodec *codec, XigError *message)

435

{

436

g_signal_emit (codec, signals[ERROR], 0, message);

437

}

438

439

void

440

xig_codec_feed_key_press (XigCodec *codec, XigKeyPress *message)

441

{

442

g_signal_emit (codec, signals[KEY_PRESS], 0, message);

443

}

444

445

void

446

xig_codec_feed_button_press (XigCodec *codec, XigButtonPress *message)

447

{

448

g_signal_emit (codec, signals[BUTTON_PRESS], 0, message);

449

}

450

451

void

452

xig_codec_feed_motion_notify (XigCodec *codec, XigMotionNotify *message)

453

{

454

g_signal_emit (codec, signals[MOTION_NOTIFY], 0, message);

455

}

456

457

void

458

xig_codec_feed_enter_notify (XigCodec *codec, XigEnterNotify *message)

459

{

460

g_signal_emit (codec, signals[ENTER_NOTIFY], 0, message);

461

}

462

463

void

464

xig_codec_feed_focus_in (XigCodec *codec, XigFocusIn *message)

465

{

466

g_signal_emit (codec, signals[FOCUS_IN], 0, message);

467

}

468

469

void

470

xig_codec_feed_keymap_notify (XigCodec *codec, XigKeymapNotify *message)

471

{

472

g_signal_emit (codec, signals[KEYMAP_NOTIFY], 0, message);

473

}

474

475

void

476

xig_codec_feed_expose (XigCodec *codec, XigExpose *message)

477

{

478

g_signal_emit (codec, signals[EXPOSE], 0, message);

479

}

480

481

void

482

xig_codec_feed_graphics_exposure (XigCodec *codec, XigGraphicsExposure *message)

483

{

484

g_signal_emit (codec, signals[GRAPHICS_EXPOSURE], 0, message);

485

}

486

487

void

488

xig_codec_feed_no_exposure (XigCodec *codec, XigNoExposure *message)

489

{

490

g_signal_emit (codec, signals[NO_EXPOSURE], 0, message);

491

}

492

493

void

494

xig_codec_feed_visibility_notify (XigCodec *codec, XigVisibilityNotify *message)

495

{

496

g_signal_emit (codec, signals[VISIBILITY_NOTIFY], 0, message);

497

}

498

499

void

500

xig_codec_feed_create_notify (XigCodec *codec, XigCreateNotify *message)

501

{

502

g_signal_emit (codec, signals[CREATE_NOTIFY], 0, message);

503

}

504

505

void

506

xig_codec_feed_destroy_notify (XigCodec *codec, XigDestroyNotify *message)

507

{

508

g_signal_emit (codec, signals[DESTROY_NOTIFY], 0, message);

509

}

510

511

void

512

xig_codec_feed_unmap_notify (XigCodec *codec, XigUnmapNotify *message)

513

{

514

g_signal_emit (codec, signals[UNMAP_NOTIFY], 0, message);

515

}

516

517

void

518

xig_codec_feed_map_notify (XigCodec *codec, XigMapNotify *message)

519

{

520

g_signal_emit (codec, signals[MAP_NOTIFY], 0, message);

521

}

522

523

void

524

xig_codec_feed_map_request (XigCodec *codec, XigMapRequest *message)

525

{

526

g_signal_emit (codec, signals[MAP_REQUEST], 0, message);

527

}

528

529

void

530

xig_codec_feed_reparent_notify (XigCodec *codec, XigReparentNotify *message)

531

{

532

g_signal_emit (codec, signals[REPARENT_NOTIFY], 0, message);

533

}

534

535

void

536

xig_codec_feed_configure_notify (XigCodec *codec, XigConfigureNotify *message)

537

{

538

g_signal_emit (codec, signals[CONFIGURE_NOTIFY], 0, message);

539

}

540

541

void

542

xig_codec_feed_configure_request (XigCodec *codec, XigConfigureRequest *message)

543

{

544

g_signal_emit (codec, signals[CONFIGURE_REQUEST], 0, message);

545

}

546

547

void

548

xig_codec_feed_gravity_notify (XigCodec *codec, XigGravityNotify *message)

549

{

550

g_signal_emit (codec, signals[GRAVITY_NOTIFY], 0, message);

551

}

552

553

void

554

xig_codec_feed_resize_request (XigCodec *codec, XigResizeRequest *message)

555

{

556

g_signal_emit (codec, signals[RESIZE_REQUEST], 0, message);

557

}

558

559

void

560

xig_codec_feed_circulate_notify (XigCodec *codec, XigCirculateNotify *message)

561

{

562

g_signal_emit (codec, signals[CIRCULATE_NOTIFY], 0, message);

563

}

564

565

void

566

xig_codec_feed_circulate_request (XigCodec *codec, XigCirculateRequest *message)

567

{

568

g_signal_emit (codec, signals[CIRCULATE_REQUEST], 0, message);

569

}

570

571

void

572

xig_codec_feed_property_notify (XigCodec *codec, XigPropertyNotify *message)

573

{

574

g_signal_emit (codec, signals[PROPERTY_NOTIFY], 0, message);

575

}

576

577

void

578

xig_codec_feed_selection_clear (XigCodec *codec, XigSelectionClear *message)

579

{

580

g_signal_emit (codec, signals[SELECTION_CLEAR], 0, message);

581

}

582

583

void

584

xig_codec_feed_selection_request (XigCodec *codec, XigSelectionRequest *message)

585

{

586

g_signal_emit (codec, signals[SELECTION_REQUEST], 0, message);

587

}

588

589

void

590

xig_codec_feed_selection_notify (XigCodec *codec, XigSelectionNotify *message)

591

{

592

g_signal_emit (codec, signals[SELECTION_NOTIFY], 0, message);

593

}

594

595

void

596

xig_codec_feed_colormap_notify (XigCodec *codec, XigColormapNotify *message)

597

{

598

g_signal_emit (codec, signals[COLORMAP_NOTIFY], 0, message);

599

}

600

601

void

602

xig_codec_feed_client_message (XigCodec *codec, XigClientMessage *message)

603

{

604

g_signal_emit (codec, signals[CLIENT_MESSAGE], 0, message);

605

}

606

607

void

608

xig_codec_feed_mapping_notify (XigCodec *codec, XigMappingNotify *message)

609

{

610

g_signal_emit (codec, signals[MAPPING_NOTIFY], 0, message);

611

}

612

613

void

614

xig_codec_feed_create_window (XigCodec *codec, XigCreateWindow *message)

615

{

616

g_signal_emit (codec, signals[CREATE_WINDOW], 0, message);

617

}

618

619

void

620

xig_codec_feed_change_window_attributes (XigCodec *codec, XigChangeWindowAttributes *message)

621

{

622

g_signal_emit (codec, signals[CHANGE_WINDOW_ATTRIBUTES], 0, message);

623

}

624

625

void

626

xig_codec_feed_get_window_attributes (XigCodec *codec, XigGetWindowAttributes *message)

627

{

628

g_signal_emit (codec, signals[GET_WINDOW_ATTRIBUTES], 0, message);

629

}

630

631

void

632

xig_codec_feed_get_window_attributes_reply (XigCodec *codec, XigGetWindowAttributesReply *message)

633

{

634

g_signal_emit (codec, signals[GET_WINDOW_ATTRIBUTES_REPLY], 0, message);

635

}

636

637

void

638

xig_codec_feed_destroy_window (XigCodec *codec, XigDestroyWindow *message)

639

{

640

g_signal_emit (codec, signals[DESTROY_WINDOW], 0, message);

641

}

642

643

void

644

xig_codec_feed_destroy_subwindows (XigCodec *codec, XigDestroySubwindows *message)

645

{

646

g_signal_emit (codec, signals[DESTROY_SUBWINDOWS], 0, message);

647

}

648

649

void

650

xig_codec_feed_change_save_set (XigCodec *codec, XigChangeSaveSet *message)

651

{

652

g_signal_emit (codec, signals[CHANGE_SAVE_SET], 0, message);

653

}

654

655

void

656

xig_codec_feed_reparent_window (XigCodec *codec, XigReparentWindow *message)

657

{

658

g_signal_emit (codec, signals[REPARENT_WINDOW], 0, message);

659

}

660

661

void

662

xig_codec_feed_map_window (XigCodec *codec, XigMapWindow *message)

663

{

664

g_signal_emit (codec, signals[MAP_WINDOW], 0, message);

665

}

666

667

void

668

xig_codec_feed_map_subwindows (XigCodec *codec, XigMapSubwindows *message)

669

{

670

g_signal_emit (codec, signals[MAP_SUBWINDOWS], 0, message);

671

}

672

673

void

674

xig_codec_feed_unmap_window (XigCodec *codec, XigUnmapWindow *message)

675

{

676

g_signal_emit (codec, signals[UNMAP_WINDOW], 0, message);

677

}

678

679

void

680

xig_codec_feed_unmap_subwindows (XigCodec *codec, XigUnmapSubwindows *message)

681

{

682

g_signal_emit (codec, signals[UNMAP_SUBWINDOWS], 0, message);

683

}

684

685

void

686

xig_codec_feed_configure_window (XigCodec *codec, XigConfigureWindow *message)

687

{

688

g_signal_emit (codec, signals[CONFIGURE_WINDOW], 0, message);

689

}

690

691

void

692

xig_codec_feed_circulate_window (XigCodec *codec, XigCirculateWindow *message)

693

{

694

g_signal_emit (codec, signals[CIRCULATE_WINDOW], 0, message);

695

}

696

697

void

698

xig_codec_feed_get_geometry (XigCodec *codec, XigGetGeometry *message)

699

{

700

g_signal_emit (codec, signals[GET_GEOMETRY], 0, message);

701

}

702

703

void

704

xig_codec_feed_get_geometry_reply (XigCodec *codec, XigGetGeometryReply *message)

705

{

706

g_signal_emit (codec, signals[GET_GEOMETRY_REPLY], 0, message);

707

}

708

709

void

710

xig_codec_feed_query_tree (XigCodec *codec, XigQueryTree *message)

711

{

712

g_signal_emit (codec, signals[QUERY_TREE], 0, message);

713

}

714

715

void

716

xig_codec_feed_query_tree_reply (XigCodec *codec, XigQueryTreeReply *message)

717

{

718

g_signal_emit (codec, signals[QUERY_TREE_REPLY], 0, message);

719

}

720

721

void

722

xig_codec_feed_intern_atom (XigCodec *codec, XigInternAtom *message)

723

{

724

g_signal_emit (codec, signals[INTERN_ATOM], 0, message);

725

}

726

727

void

728

xig_codec_feed_intern_atom_reply (XigCodec *codec, XigInternAtomReply *message)

729

{

730

g_signal_emit (codec, signals[INTERN_ATOM_REPLY], 0, message);

731

}

732

733

void

734

xig_codec_feed_get_atom_name (XigCodec *codec, XigGetAtomName *message)

735

{

736

g_signal_emit (codec, signals[GET_ATOM_NAME], 0, message);

737

}

738

739

void

740

xig_codec_feed_get_atom_name_reply (XigCodec *codec, XigGetAtomNameReply *message)

741

{

742

g_signal_emit (codec, signals[GET_ATOM_NAME_REPLY], 0, message);

743

}

744

745

void

746

xig_codec_feed_change_property (XigCodec *codec, XigChangeProperty *message)

747

{

748

g_signal_emit (codec, signals[CHANGE_PROPERTY], 0, message);

749

}

750

751

void

752

xig_codec_feed_delete_property (XigCodec *codec, XigDeleteProperty *message)

753

{

754

g_signal_emit (codec, signals[DELETE_PROPERTY], 0, message);

755

}

756

757

void

758

xig_codec_feed_get_property (XigCodec *codec, XigGetProperty *message)

759

{

760

g_signal_emit (codec, signals[GET_PROPERTY], 0, message);

761

}

762

763

void

764

xig_codec_feed_get_property_reply (XigCodec *codec, XigGetPropertyReply *message)

765

{

766

g_signal_emit (codec, signals[GET_PROPERTY_REPLY], 0, message);

767

}

768

769

void

770

xig_codec_feed_list_properties (XigCodec *codec, XigListProperties *message)

771

{

772

g_signal_emit (codec, signals[LIST_PROPERTIES], 0, message);

773

}

774

775

void

776

xig_codec_feed_list_properties_reply (XigCodec *codec, XigListPropertiesReply *message)

777

{

778

g_signal_emit (codec, signals[LIST_PROPERTIES_REPLY], 0, message);

779

}

780

781

void

782

xig_codec_feed_set_selection_owner (XigCodec *codec, XigSetSelectionOwner *message)

783

{

784

g_signal_emit (codec, signals[SET_SELECTION_OWNER], 0, message);

785

}

786

787

void

788

xig_codec_feed_get_selection_owner (XigCodec *codec, XigGetSelectionOwner *message)

789

{

790

g_signal_emit (codec, signals[GET_SELECTION_OWNER], 0, message);

791

}

792

793

void

794

xig_codec_feed_get_selection_owner_reply (XigCodec *codec, XigGetSelectionOwnerReply *message)

795

{

796

g_signal_emit (codec, signals[GET_SELECTION_OWNER_REPLY], 0, message);

797

}

798

799

void

800

xig_codec_feed_convert_selection (XigCodec *codec, XigConvertSelection *message)

801

{

802

g_signal_emit (codec, signals[CONVERT_SELECTION], 0, message);

803

}

804

805

void

806

xig_codec_feed_send_event (XigCodec *codec, XigSendEvent *message)

807

{

808

g_signal_emit (codec, signals[SEND_EVENT], 0, message);

809

}

810

811

void

812

xig_codec_feed_grab_pointer (XigCodec *codec, XigGrabPointer *message)

813

{

814

g_signal_emit (codec, signals[GRAB_POINTER], 0, message);

815

}

816

817

void

818

xig_codec_feed_grab_pointer_reply (XigCodec *codec, XigGrabPointerReply *message)

819

{

820

g_signal_emit (codec, signals[GRAB_POINTER_REPLY], 0, message);

821

}

822

823

void

824

xig_codec_feed_ungrab_pointer (XigCodec *codec, XigUngrabPointer *message)

825

{

826

g_signal_emit (codec, signals[UNGRAB_POINTER], 0, message);

827

}

828

829

void

830

xig_codec_feed_grab_button (XigCodec *codec, XigGrabButton *message)

831

{

832

g_signal_emit (codec, signals[GRAB_BUTTON], 0, message);

833

}

834

835

void

836

xig_codec_feed_ungrab_button (XigCodec *codec, XigUngrabButton *message)

837

{

838

g_signal_emit (codec, signals[UNGRAB_BUTTON], 0, message);

839

}

840

841

void

842

xig_codec_feed_change_active_pointer_grab (XigCodec *codec, XigChangeActivePointerGrab *message)

843

{

844

g_signal_emit (codec, signals[CHANGE_ACTIVE_POINTER_GRAB], 0, message);

845

}

846

847

void

848

xig_codec_feed_grab_keyboard (XigCodec *codec, XigGrabKeyboard *message)

849

{

850

g_signal_emit (codec, signals[GRAB_KEYBOARD], 0, message);

851

}

852

853

void

854

xig_codec_feed_grab_keyboard_reply (XigCodec *codec, XigGrabKeyboardReply *message)

855

{

856

g_signal_emit (codec, signals[GRAB_KEYBOARD_REPLY], 0, message);

857

}

858

859

void

860

xig_codec_feed_ungrab_keyboard (XigCodec *codec, XigUngrabKeyboard *message)

861

{

862

g_signal_emit (codec, signals[UNGRAB_KEYBOARD], 0, message);

863

}

864

865

void

866

xig_codec_feed_grab_key (XigCodec *codec, XigGrabKey *message)

867

{

868

g_signal_emit (codec, signals[GRAB_KEY], 0, message);

869

}

870

871

void

872

xig_codec_feed_ungrab_key (XigCodec *codec, XigUngrabKey *message)

873

{

874

g_signal_emit (codec, signals[UNGRAB_KEY], 0, message);

875

}

876

877

void

878

xig_codec_feed_allow_events (XigCodec *codec, XigAllowEvents *message)

879

{

880

g_signal_emit (codec, signals[ALLOW_EVENTS], 0, message);

881

}

882

883

void

884

xig_codec_feed_grab_server (XigCodec *codec, XigGrabServer *message)

885

{

886

g_signal_emit (codec, signals[GRAB_SERVER], 0, message);

887

}

888

889

void

890

xig_codec_feed_ungrab_server (XigCodec *codec, XigUngrabServer *message)

891

{

892

g_signal_emit (codec, signals[UNGRAB_SERVER], 0, message);

893

}

894

895

void

896

xig_codec_feed_query_pointer (XigCodec *codec, XigQueryPointer *message)

897

{

898

g_signal_emit (codec, signals[QUERY_POINTER], 0, message);

899

}

900

901

void

902

xig_codec_feed_query_pointer_reply (XigCodec *codec, XigQueryPointerReply *message)

903

{

904

g_signal_emit (codec, signals[QUERY_POINTER_REPLY], 0, message);

905

}

906

907

void

908

xig_codec_feed_get_motion_events (XigCodec *codec, XigGetMotionEvents *message)

909

{

910

g_signal_emit (codec, signals[GET_MOTION_EVENTS], 0, message);

911

}

912

913

void

914

xig_codec_feed_get_motion_events_reply (XigCodec *codec, XigGetMotionEventsReply *message)

915

{

916

g_signal_emit (codec, signals[GET_MOTION_EVENTS_REPLY], 0, message);

917

}

918

919

void

920

xig_codec_feed_translate_coordinates (XigCodec *codec, XigTranslateCoordinates *message)

921

{

922

g_signal_emit (codec, signals[TRANSLATE_COORDINATES], 0, message);

923

}

924

925

void

926

xig_codec_feed_translate_coordinates_reply (XigCodec *codec, XigTranslateCoordinatesReply *message)

927

{

928

g_signal_emit (codec, signals[TRANSLATE_COORDINATES_REPLY], 0, message);

929

}

930

931

void

932

xig_codec_feed_warp_pointer (XigCodec *codec, XigWarpPointer *message)

933

{

934

g_signal_emit (codec, signals[WARP_POINTER], 0, message);

935

}

936

937

void

938

xig_codec_feed_set_input_focus (XigCodec *codec, XigSetInputFocus *message)

939

{

940

g_signal_emit (codec, signals[SET_INPUT_FOCUS], 0, message);

941

}

942

943

void

944

xig_codec_feed_get_input_focus (XigCodec *codec, XigGetInputFocus *message)

945

{

946

g_signal_emit (codec, signals[GET_INPUT_FOCUS], 0, message);

947

}

948

949

void

950

xig_codec_feed_get_input_focus_reply (XigCodec *codec, XigGetInputFocusReply *message)

951

{

952

g_signal_emit (codec, signals[GET_INPUT_FOCUS_REPLY], 0, message);

953

}

954

955

void

956

xig_codec_feed_query_keymap (XigCodec *codec, XigQueryKeymap *message)

957

{

958

g_signal_emit (codec, signals[QUERY_KEYMAP], 0, message);

959

}

960

961

void

962

xig_codec_feed_query_keymap_reply (XigCodec *codec, XigQueryKeymapReply *message)

963

{

964

g_signal_emit (codec, signals[QUERY_KEYMAP_REPLY], 0, message);

965

}

966

967

void

968

xig_codec_feed_open_font (XigCodec *codec, XigOpenFont *message)

969

{

970

g_signal_emit (codec, signals[OPEN_FONT], 0, message);

971

}

972

973

void

974

xig_codec_feed_close_font (XigCodec *codec, XigCloseFont *message)

975

{

976

g_signal_emit (codec, signals[CLOSE_FONT], 0, message);

977

}

978

979

void

980

xig_codec_feed_query_font (XigCodec *codec, XigQueryFont *message)

981

{

982

g_signal_emit (codec, signals[QUERY_FONT], 0, message);

983

}

984

985

void

986

xig_codec_feed_query_font_reply (XigCodec *codec, XigQueryFontReply *message)

987

{

988

g_signal_emit (codec, signals[QUERY_FONT_REPLY], 0, message);

989

}

990

991

void

992

xig_codec_feed_query_text_extents (XigCodec *codec, XigQueryTextExtents *message)

993

{

994

g_signal_emit (codec, signals[QUERY_TEXT_EXTENTS], 0, message);

995

}

996

997

void

998

xig_codec_feed_query_text_extents_reply (XigCodec *codec, XigQueryTextExtentsReply *message)

999

{

1000

g_signal_emit (codec, signals[QUERY_TEXT_EXTENTS_REPLY], 0, message);

1001

}

1002

1003

void

1004

xig_codec_feed_list_fonts (XigCodec *codec, XigListFonts *message)

1005

{

1006

g_signal_emit (codec, signals[LIST_FONTS], 0, message);

1007

}

1008

1009

void

1010

xig_codec_feed_list_fonts_reply (XigCodec *codec, XigListFontsReply *message)

1011

{

1012

g_signal_emit (codec, signals[LIST_FONTS_REPLY], 0, message);

1013

}

1014

1015

void

1016

xig_codec_feed_list_fonts_with_info (XigCodec *codec, XigListFontsWithInfo *message)

1017

{

1018

g_signal_emit (codec, signals[LIST_FONTS_WITH_INFO], 0, message);

1019

}

1020

1021

void

1022

xig_codec_feed_list_fonts_with_info_reply (XigCodec *codec, XigListFontsWithInfoReply *message)

1023

{

1024

g_signal_emit (codec, signals[LIST_FONTS_WITH_INFO_REPLY], 0, message);

1025

}

1026

1027

void

1028

xig_codec_feed_set_font_path (XigCodec *codec, XigSetFontPath *message)

1029

{

1030

g_signal_emit (codec, signals[SET_FONT_PATH], 0, message);

1031

}

1032

1033

void

1034

xig_codec_feed_get_font_path (XigCodec *codec, XigGetFontPath *message)

1035

{

1036

g_signal_emit (codec, signals[GET_FONT_PATH], 0, message);

1037

}

1038

1039

void

1040

xig_codec_feed_get_font_path_reply (XigCodec *codec, XigGetFontPathReply *message)

1041

{

1042

g_signal_emit (codec, signals[GET_FONT_PATH_REPLY], 0, message);

1043

}

1044

1045

void

1046

xig_codec_feed_create_pixmap (XigCodec *codec, XigCreatePixmap *message)

1047

{

1048

g_signal_emit (codec, signals[CREATE_PIXMAP], 0, message);

1049

}

1050

1051

void

1052

xig_codec_feed_free_pixmap (XigCodec *codec, XigFreePixmap *message)

1053

{

1054

g_signal_emit (codec, signals[FREE_PIXMAP], 0, message);

1055

}

1056

1057

void

1058

xig_codec_feed_create_gc (XigCodec *codec, XigCreateGC *message)

1059

{

1060

g_signal_emit (codec, signals[CREATE_GC], 0, message);

1061

}

1062

1063

void

1064

xig_codec_feed_change_gc (XigCodec *codec, XigChangeGC *message)

1065

{

1066

g_signal_emit (codec, signals[CHANGE_GC], 0, message);

1067

}

1068

1069

void

1070

xig_codec_feed_copy_gc (XigCodec *codec, XigCopyGC *message)

1071

{

1072

g_signal_emit (codec, signals[COPY_GC], 0, message);

1073

}

1074

1075

void

1076

xig_codec_feed_set_dashes (XigCodec *codec, XigSetDashes *message)

1077

{

1078

g_signal_emit (codec, signals[SET_DASHES], 0, message);

1079

}

1080

1081

void

1082

xig_codec_feed_set_clip_rectangles (XigCodec *codec, XigSetClipRectangles *message)

1083

{

1084

g_signal_emit (codec, signals[SET_CLIP_RECTANGLES], 0, message);

1085

}

1086

1087

void

1088

xig_codec_feed_free_gc (XigCodec *codec, XigFreeGC *message)

1089

{

1090

g_signal_emit (codec, signals[FREE_GC], 0, message);

1091

}

1092

1093

void

1094

xig_codec_feed_clear_area (XigCodec *codec, XigClearArea *message)

1095

{

1096

g_signal_emit (codec, signals[CLEAR_AREA], 0, message);

1097

}

1098

1099

void

1100

xig_codec_feed_copy_area (XigCodec *codec, XigCopyArea *message)

1101

{

1102

g_signal_emit (codec, signals[COPY_AREA], 0, message);

1103

}

1104

1105

void

1106

xig_codec_feed_copy_plane (XigCodec *codec, XigCopyPlane *message)

1107

{

1108

g_signal_emit (codec, signals[COPY_PLANE], 0, message);

1109

}

1110

1111

void

1112

xig_codec_feed_poly_point (XigCodec *codec, XigPolyPoint *message)

1113

{

1114

g_signal_emit (codec, signals[POLY_POINT], 0, message);

1115

}

1116

1117

void

1118

xig_codec_feed_poly_line (XigCodec *codec, XigPolyLine *message)

1119

{

1120

g_signal_emit (codec, signals[POLY_LINE], 0, message);

1121

}

1122

1123

void

1124

xig_codec_feed_poly_segment (XigCodec *codec, XigPolySegment *message)

1125

{

1126

g_signal_emit (codec, signals[POLY_SEGMENT], 0, message);

1127

}

1128

1129

void

1130

xig_codec_feed_poly_rectangle (XigCodec *codec, XigPolyRectangle *message)

1131

{

1132

g_signal_emit (codec, signals[POLY_RECTANGLE], 0, message);

1133

}

1134

1135

void

1136

xig_codec_feed_poly_arc (XigCodec *codec, XigPolyArc *message)

1137

{

1138

g_signal_emit (codec, signals[POLY_ARC], 0, message);

1139

}

1140

1141

void

1142

xig_codec_feed_fill_poly (XigCodec *codec, XigFillPoly *message)

1143

{

1144

g_signal_emit (codec, signals[FILL_POLY], 0, message);

1145

}

1146

1147

void

1148

xig_codec_feed_poly_fill_rectangle (XigCodec *codec, XigPolyFillRectangle *message)

1149

{

1150

g_signal_emit (codec, signals[POLY_FILL_RECTANGLE], 0, message);

1151

}

1152

1153

void

1154

xig_codec_feed_poly_fill_arc (XigCodec *codec, XigPolyFillArc *message)

1155

{

1156

g_signal_emit (codec, signals[POLY_FILL_ARC], 0, message);

1157

}

1158

1159

void

1160

xig_codec_feed_put_image (XigCodec *codec, XigPutImage *message)

1161

{

1162

g_signal_emit (codec, signals[PUT_IMAGE], 0, message);

1163

}

1164

1165

void

1166

xig_codec_feed_get_image (XigCodec *codec, XigGetImage *message)

1167

{

1168

g_signal_emit (codec, signals[GET_IMAGE], 0, message);

1169

}

1170

1171

void

1172

xig_codec_feed_get_image_reply (XigCodec *codec, XigGetImageReply *message)

1173

{

1174

g_signal_emit (codec, signals[GET_IMAGE_REPLY], 0, message);

1175

}

1176

1177

void

1178

xig_codec_feed_poly_text8 (XigCodec *codec, XigPolyText8 *message)

1179

{

1180

g_signal_emit (codec, signals[POLY_TEXT8], 0, message);

1181

}

1182

1183

void

1184

xig_codec_feed_poly_text16 (XigCodec *codec, XigPolyText16 *message)

1185

{

1186

g_signal_emit (codec, signals[POLY_TEXT16], 0, message);

1187

}

1188

1189

void

1190

xig_codec_feed_image_text8 (XigCodec *codec, XigImageText8 *message)

1191

{

1192

g_signal_emit (codec, signals[IMAGE_TEXT8], 0, message);

1193

}

1194

1195

void

1196

xig_codec_feed_image_text16 (XigCodec *codec, XigImageText16 *message)

1197

{

1198

g_signal_emit (codec, signals[IMAGE_TEXT16], 0, message);

1199

}

1200

1201

void

1202

xig_codec_feed_create_colormap (XigCodec *codec, XigCreateColormap *message)

1203

{

1204

g_signal_emit (codec, signals[CREATE_COLORMAP], 0, message);

1205

}

1206

1207

void

1208

xig_codec_feed_free_colormap (XigCodec *codec, XigFreeColormap *message)

1209

{

1210

g_signal_emit (codec, signals[FREE_COLORMAP], 0, message);

1211

}

1212

1213

void

1214

xig_codec_feed_copy_colormap_and_free (XigCodec *codec, XigCopyColormapAndFree *message)

1215

{

1216

g_signal_emit (codec, signals[COPY_COLORMAP_AND_FREE], 0, message);

1217

}

1218

1219

void

1220

xig_codec_feed_install_colormap (XigCodec *codec, XigInstallColormap *message)

1221

{

1222

g_signal_emit (codec, signals[INSTALL_COLORMAP], 0, message);

1223

}

1224

1225

void

1226

xig_codec_feed_uninstall_colormap (XigCodec *codec, XigUninstallColormap *message)

1227

{

1228

g_signal_emit (codec, signals[UNINSTALL_COLORMAP], 0, message);

1229

}

1230

1231

void

1232

xig_codec_feed_list_installed_colormaps (XigCodec *codec, XigListInstalledColormaps *message)

1233

{

1234

g_signal_emit (codec, signals[LIST_INSTALLED_COLORMAPS], 0, message);

1235

}

1236

1237

void

1238

xig_codec_feed_list_installed_colormaps_reply (XigCodec *codec, XigListInstalledColormapsReply *message)

1239

{

1240

g_signal_emit (codec, signals[LIST_INSTALLED_COLORMAPS_REPLY], 0, message);

1241

}

1242

1243

void

1244

xig_codec_feed_alloc_color (XigCodec *codec, XigAllocColor *message)

1245

{

1246

g_signal_emit (codec, signals[ALLOC_COLOR], 0, message);

1247

}

1248

1249

void

1250

xig_codec_feed_alloc_color_reply (XigCodec *codec, XigAllocColorReply *message)

1251

{

1252

g_signal_emit (codec, signals[ALLOC_COLOR_REPLY], 0, message);

1253

}

1254

1255

void

1256

xig_codec_feed_alloc_named_color (XigCodec *codec, XigAllocNamedColor *message)

1257

{

1258

g_signal_emit (codec, signals[ALLOC_NAMED_COLOR], 0, message);

1259

}

1260

1261

void

1262

xig_codec_feed_alloc_named_color_reply (XigCodec *codec, XigAllocNamedColorReply *message)

1263

{

1264

g_signal_emit (codec, signals[ALLOC_NAMED_COLOR_REPLY], 0, message);

1265

}

1266

1267

void

1268

xig_codec_feed_alloc_color_cells (XigCodec *codec, XigAllocColorCells *message)

1269

{

1270

g_signal_emit (codec, signals[ALLOC_COLOR_CELLS], 0, message);

1271

}

1272

1273

void

1274

xig_codec_feed_alloc_color_cells_reply (XigCodec *codec, XigAllocColorCellsReply *message)

1275

{

1276

g_signal_emit (codec, signals[ALLOC_COLOR_CELLS_REPLY], 0, message);

1277

}

1278

1279

void

1280

xig_codec_feed_alloc_color_planes (XigCodec *codec, XigAllocColorPlanes *message)

1281

{

1282

g_signal_emit (codec, signals[ALLOC_COLOR_PLANES], 0, message);

1283

}

1284

1285

void

1286

xig_codec_feed_alloc_color_planes_reply (XigCodec *codec, XigAllocColorPlanesReply *message)

1287

{

1288

g_signal_emit (codec, signals[ALLOC_COLOR_PLANES_REPLY], 0, message);

1289

}

1290

1291

void

1292

xig_codec_feed_free_colors (XigCodec *codec, XigFreeColors *message)

1293

{

1294

g_signal_emit (codec, signals[FREE_COLORS], 0, message);

1295

}

1296

1297

void

1298

xig_codec_feed_store_colors (XigCodec *codec, XigStoreColors *message)

1299

{

1300

g_signal_emit (codec, signals[STORE_COLORS], 0, message);

1301

}

1302

1303

void

1304

xig_codec_feed_store_named_color (XigCodec *codec, XigStoreNamedColor *message)

1305

{

1306

g_signal_emit (codec, signals[STORE_NAMED_COLOR], 0, message);

1307

}

1308

1309

void

1310

xig_codec_feed_query_colors (XigCodec *codec, XigQueryColors *message)

1311

{

1312

g_signal_emit (codec, signals[QUERY_COLORS], 0, message);

1313

}

1314

1315

void

1316

xig_codec_feed_query_colors_reply (XigCodec *codec, XigQueryColorsReply *message)

1317

{

1318

g_signal_emit (codec, signals[QUERY_COLORS_REPLY], 0, message);

1319

}

1320

1321

void

1322

xig_codec_feed_lookup_color (XigCodec *codec, XigLookupColor *message)

1323

{

1324

g_signal_emit (codec, signals[LOOKUP_COLOR], 0, message);

1325

}

1326

1327

void

1328

xig_codec_feed_lookup_color_reply (XigCodec *codec, XigLookupColorReply *message)

1329

{

1330

g_signal_emit (codec, signals[LOOKUP_COLOR_REPLY], 0, message);

1331

}

1332

1333

void

1334

xig_codec_feed_create_cursor (XigCodec *codec, XigCreateCursor *message)

1335

{

1336

g_signal_emit (codec, signals[CREATE_CURSOR], 0, message);

1337

}

1338

1339

void

1340

xig_codec_feed_create_glyph_cursor (XigCodec *codec, XigCreateGlyphCursor *message)

1341

{

1342

g_signal_emit (codec, signals[CREATE_GLYPH_CURSOR], 0, message);

1343

}

1344

1345

void

1346

xig_codec_feed_free_cursor (XigCodec *codec, XigFreeCursor *message)

1347

{

1348

g_signal_emit (codec, signals[FREE_CURSOR], 0, message);

1349

}

1350

1351

void

1352

xig_codec_feed_recolor_cursor (XigCodec *codec, XigRecolorCursor *message)

1353

{

1354

g_signal_emit (codec, signals[RECOLOR_CURSOR], 0, message);

1355

}

1356

1357

void

1358

xig_codec_feed_query_best_size (XigCodec *codec, XigQueryBestSize *message)

1359

{

1360

g_signal_emit (codec, signals[QUERY_BEST_SIZE], 0, message);

1361

}

1362

1363

void

1364

xig_codec_feed_query_best_size_reply (XigCodec *codec, XigQueryBestSizeReply *message)

1365

{

1366

g_signal_emit (codec, signals[QUERY_BEST_SIZE_REPLY], 0, message);

1367

}

1368

1369

void

1370

xig_codec_feed_query_extension (XigCodec *codec, XigQueryExtension *message)

1371

{

1372

g_signal_emit (codec, signals[QUERY_EXTENSION], 0, message);

1373

}

1374

1375

void

1376

xig_codec_feed_query_extension_reply (XigCodec *codec, XigQueryExtensionReply *message)

1377

{

1378

g_signal_emit (codec, signals[QUERY_EXTENSION_REPLY], 0, message);

1379

}

1380

1381

void

1382

xig_codec_feed_list_extensions (XigCodec *codec, XigListExtensions *message)

1383

{

1384

g_signal_emit (codec, signals[LIST_EXTENSIONS], 0, message);

1385

}

1386

1387

void

1388

xig_codec_feed_list_extensions_reply (XigCodec *codec, XigListExtensionsReply *message)

1389

{

1390

g_signal_emit (codec, signals[LIST_EXTENSIONS_REPLY], 0, message);

1391

}

1392

1393

void

1394

xig_codec_feed_change_keyboard_mapping (XigCodec *codec, XigChangeKeyboardMapping *message)

1395

{

1396

g_signal_emit (codec, signals[CHANGE_KEYBOARD_MAPPING], 0, message);

1397

}

1398

1399

void

1400

xig_codec_feed_get_keyboard_mapping (XigCodec *codec, XigGetKeyboardMapping *message)

1401

{

1402

g_signal_emit (codec, signals[GET_KEYBOARD_MAPPING], 0, message);

1403

}

1404

1405

void

1406

xig_codec_feed_get_keyboard_mapping_reply (XigCodec *codec, XigGetKeyboardMappingReply *message)

1407

{

1408

g_signal_emit (codec, signals[GET_KEYBOARD_MAPPING_REPLY], 0, message);

1409

}

1410

1411

void

1412

xig_codec_feed_change_keyboard_control (XigCodec *codec, XigChangeKeyboardControl *message)

1413

{

1414

g_signal_emit (codec, signals[CHANGE_KEYBOARD_CONTROL], 0, message);

1415

}

1416

1417

void

1418

xig_codec_feed_get_keyboard_control (XigCodec *codec, XigGetKeyboardControl *message)

1419

{

1420

g_signal_emit (codec, signals[GET_KEYBOARD_CONTROL], 0, message);

1421

}

1422

1423

void

1424

xig_codec_feed_get_keyboard_control_reply (XigCodec *codec, XigGetKeyboardControlReply *message)

1425

{

1426

g_signal_emit (codec, signals[GET_KEYBOARD_CONTROL_REPLY], 0, message);

1427

}

1428

1429

void

1430

xig_codec_feed_bell (XigCodec *codec, XigBell *message)

1431

{

1432

g_signal_emit (codec, signals[BELL], 0, message);

1433

}

1434

1435

void

1436

xig_codec_feed_change_pointer_control (XigCodec *codec, XigChangePointerControl *message)

1437

{

1438

g_signal_emit (codec, signals[CHANGE_POINTER_CONTROL], 0, message);

1439

}

1440

1441

void

1442

xig_codec_feed_get_pointer_control (XigCodec *codec, XigGetPointerControl *message)

1443

{

1444

g_signal_emit (codec, signals[GET_POINTER_CONTROL], 0, message);

1445

}

1446

1447

void

1448

xig_codec_feed_get_pointer_control_reply (XigCodec *codec, XigGetPointerControlReply *message)

1449

{

1450

g_signal_emit (codec, signals[GET_POINTER_CONTROL_REPLY], 0, message);

1451

}

1452

1453

void

1454

xig_codec_feed_set_screen_saver (XigCodec *codec, XigSetScreenSaver *message)

1455

{

1456

g_signal_emit (codec, signals[SET_SCREEN_SAVER], 0, message);

1457

}

1458

1459

void

1460

xig_codec_feed_get_screen_saver (XigCodec *codec, XigGetScreenSaver *message)

1461

{

1462

g_signal_emit (codec, signals[GET_SCREEN_SAVER], 0, message);

1463

}

1464

1465

void

1466

xig_codec_feed_get_screen_saver_reply (XigCodec *codec, XigGetScreenSaverReply *message)

1467

{

1468

g_signal_emit (codec, signals[GET_SCREEN_SAVER_REPLY], 0, message);

1469

}

1470

1471

void

1472

xig_codec_feed_change_hosts (XigCodec *codec, XigChangeHosts *message)

1473

{

1474

g_signal_emit (codec, signals[CHANGE_HOSTS], 0, message);

1475

}

1476

1477

void

1478

xig_codec_feed_list_hosts (XigCodec *codec, XigListHosts *message)

1479

{

1480

g_signal_emit (codec, signals[LIST_HOSTS], 0, message);

1481

}

1482

1483

void

1484

xig_codec_feed_list_hosts_reply (XigCodec *codec, XigListHostsReply *message)

1485

{

1486

g_signal_emit (codec, signals[LIST_HOSTS_REPLY], 0, message);

1487

}

1488

1489

void

1490

xig_codec_feed_set_access_control (XigCodec *codec, XigSetAccessControl *message)

1491

{

1492

g_signal_emit (codec, signals[SET_ACCESS_CONTROL], 0, message);

1493

}

1494

1495

void

1496

xig_codec_feed_set_close_down_mode (XigCodec *codec, XigSetCloseDownMode *message)

1497

{

1498

g_signal_emit (codec, signals[SET_CLOSE_DOWN_MODE], 0, message);

1499

}

1500

1501

void

1502

xig_codec_feed_kill_client (XigCodec *codec, XigKillClient *message)

1503

{

1504

g_signal_emit (codec, signals[KILL_CLIENT], 0, message);

1505

}

1506

1507

void

1508

xig_codec_feed_rotate_properties (XigCodec *codec, XigRotateProperties *message)

1509

{

1510

g_signal_emit (codec, signals[ROTATE_PROPERTIES], 0, message);

1511

}

1512

1513

void

1514

xig_codec_feed_force_screen_saver (XigCodec *codec, XigForceScreenSaver *message)

1515

{

1516

g_signal_emit (codec, signals[FORCE_SCREEN_SAVER], 0, message);

1517

}

1518

1519

void

1520

xig_codec_feed_set_pointer_mapping (XigCodec *codec, XigSetPointerMapping *message)

1521

{

1522

g_signal_emit (codec, signals[SET_POINTER_MAPPING], 0, message);

1523

}

1524

1525

void

1526

xig_codec_feed_set_pointer_mapping_reply (XigCodec *codec, XigSetPointerMappingReply *message)

1527

{

1528

g_signal_emit (codec, signals[SET_POINTER_MAPPING_REPLY], 0, message);

1529

}

1530

1531

void

1532

xig_codec_feed_get_pointer_mapping (XigCodec *codec, XigGetPointerMapping *message)

1533

{

1534

g_signal_emit (codec, signals[GET_POINTER_MAPPING], 0, message);

1535

}

1536

1537

void

1538

xig_codec_feed_get_pointer_mapping_reply (XigCodec *codec, XigGetPointerMappingReply *message)

1539

{

1540

g_signal_emit (codec, signals[GET_POINTER_MAPPING_REPLY], 0, message);

1541

}

1542

1543

void

1544

xig_codec_feed_set_modifier_mapping (XigCodec *codec, XigSetModifierMapping *message)

1545

{

1546

g_signal_emit (codec, signals[SET_MODIFIER_MAPPING], 0, message);

1547

}

1548

1549

void

1550

xig_codec_feed_set_modifier_mapping_reply (XigCodec *codec, XigSetModifierMappingReply *message)

1551

{

1552

g_signal_emit (codec, signals[SET_MODIFIER_MAPPING_REPLY], 0, message);

1553

}

1554

1555

void

1556

xig_codec_feed_get_modifier_mapping (XigCodec *codec, XigGetModifierMapping *message)

1557

{

1558

g_signal_emit (codec, signals[GET_MODIFIER_MAPPING], 0, message);

1559

}

1560

1561

void

1562

xig_codec_feed_get_modifier_mapping_reply (XigCodec *codec, XigGetModifierMappingReply *message)

1563

{

1564

g_signal_emit (codec, signals[GET_MODIFIER_MAPPING_REPLY], 0, message);

1565

}

1566

1567

void

1568

xig_codec_feed_no_operation (XigCodec *codec, XigNoOperation *message)

1569

{

1570

g_signal_emit (codec, signals[NO_OPERATION], 0, message);

1571

}

1572

1573

void

1574

xig_codec_feed_BIGREQ_enable (XigCodec *codec, XigBIGREQEnable *message)

1575

{

1576

g_signal_emit (codec, signals[BIGREQ_ENABLE], 0, message);

1577

}

1578

1579

void

1580

xig_codec_feed_BIGREQ_enable_reply (XigCodec *codec, XigBIGREQEnableReply *message)

1581

{

1582

g_signal_emit (codec, signals[BIGREQ_ENABLE_REPLY], 0, message);

1583

}

1584

1585

void

1586

xig_codec_feed_SYNC_counter_notify (XigCodec *codec, XigSYNCCounterNotify *message)

1587

{

1588

g_signal_emit (codec, signals[SYNC_COUNTER_NOTIFY], 0, message);

1589

}

1590

1591

void

1592

xig_codec_feed_SYNC_alarm_notify (XigCodec *codec, XigSYNCAlarmNotify *message)

1593

{

1594

g_signal_emit (codec, signals[SYNC_ALARM_NOTIFY], 0, message);

1595

}

1596

1597

void

1598

xig_codec_feed_SYNC_initialize (XigCodec *codec, XigSYNCInitialize *message)

1599

{

1600

g_signal_emit (codec, signals[SYNC_INITIALIZE], 0, message);

1601

}

1602

1603

void

1604

xig_codec_feed_SYNC_initialize_reply (XigCodec *codec, XigSYNCInitializeReply *message)

1605

{

1606

g_signal_emit (codec, signals[SYNC_INITIALIZE_REPLY], 0, message);

1607

}

1608

1609

void

1610

xig_codec_feed_SYNC_list_system_counters (XigCodec *codec, XigSYNCListSystemCounters *message)

1611

{

1612

g_signal_emit (codec, signals[SYNC_LIST_SYSTEM_COUNTERS], 0, message);

1613

}

1614

1615

void

1616

xig_codec_feed_SYNC_list_system_counters_reply (XigCodec *codec, XigSYNCListSystemCountersReply *message)

1617

{

1618

g_signal_emit (codec, signals[SYNC_LIST_SYSTEM_COUNTERS_REPLY], 0, message);

1619

}

1620

1621

void

1622

xig_codec_feed_SYNC_create_counter (XigCodec *codec, XigSYNCCreateCounter *message)

1623

{

1624

g_signal_emit (codec, signals[SYNC_CREATE_COUNTER], 0, message);

1625

}

1626

1627

void

1628

xig_codec_feed_SYNC_destroy_counter (XigCodec *codec, XigSYNCDestroyCounter *message)

1629

{

1630

g_signal_emit (codec, signals[SYNC_DESTROY_COUNTER], 0, message);

1631

}

1632

1633

void

1634

xig_codec_feed_SYNC_query_counter (XigCodec *codec, XigSYNCQueryCounter *message)

1635

{

1636

g_signal_emit (codec, signals[SYNC_QUERY_COUNTER], 0, message);

1637

}

1638

1639

void

1640

xig_codec_feed_SYNC_query_counter_reply (XigCodec *codec, XigSYNCQueryCounterReply *message)

1641

{

1642

g_signal_emit (codec, signals[SYNC_QUERY_COUNTER_REPLY], 0, message);

1643

}

1644

1645

void

1646

xig_codec_feed_SYNC_await (XigCodec *codec, XigSYNCAwait *message)

1647

{

1648

g_signal_emit (codec, signals[SYNC_AWAIT], 0, message);

1649

}

1650

1651

void

1652

xig_codec_feed_SYNC_change_counter (XigCodec *codec, XigSYNCChangeCounter *message)

1653

{

1654

g_signal_emit (codec, signals[SYNC_CHANGE_COUNTER], 0, message);

1655

}

1656

1657

void

1658

xig_codec_feed_SYNC_set_counter (XigCodec *codec, XigSYNCSetCounter *message)

1659

{

1660

g_signal_emit (codec, signals[SYNC_SET_COUNTER], 0, message);

1661

}

1662

1663

void

1664

xig_codec_feed_SYNC_create_alarm (XigCodec *codec, XigSYNCCreateAlarm *message)

1665

{

1666

g_signal_emit (codec, signals[SYNC_CREATE_ALARM], 0, message);

1667

}

1668

1669

void

1670

xig_codec_feed_SYNC_change_alarm (XigCodec *codec, XigSYNCChangeAlarm *message)

1671

{

1672

g_signal_emit (codec, signals[SYNC_CHANGE_ALARM], 0, message);

1673

}

1674

1675

void

1676

xig_codec_feed_SYNC_destroy_alarm (XigCodec *codec, XigSYNCDestroyAlarm *message)

1677

{

1678

g_signal_emit (codec, signals[SYNC_DESTROY_ALARM], 0, message);

1679

}

1680

1681

void

1682

xig_codec_feed_SYNC_query_alarm (XigCodec *codec, XigSYNCQueryAlarm *message)

1683

{

1684

g_signal_emit (codec, signals[SYNC_QUERY_ALARM], 0, message);

1685

}

1686

1687

void

1688

xig_codec_feed_SYNC_query_alarm_reply (XigCodec *codec, XigSYNCQueryAlarmReply *message)

1689

{

1690

g_signal_emit (codec, signals[SYNC_QUERY_ALARM_REPLY], 0, message);

1691

}

1692

1693

void

1694

xig_codec_feed_SYNC_set_priority (XigCodec *codec, XigSYNCSetPriority *message)

1695

{

1696

g_signal_emit (codec, signals[SYNC_SET_PRIORITY], 0, message);

1697

}

1698

1699

void

1700

xig_codec_feed_SYNC_get_priority (XigCodec *codec, XigSYNCGetPriority *message)

1701

{

1702

g_signal_emit (codec, signals[SYNC_GET_PRIORITY], 0, message);

1703

}

1704

1705

void

1706

xig_codec_feed_SYNC_get_priority_reply (XigCodec *codec, XigSYNCGetPriorityReply *message)

1707

{

1708

g_signal_emit (codec, signals[SYNC_GET_PRIORITY_REPLY], 0, message);

1709

}

1710

1711

void

1712

xig_codec_feed_SYNC_create_fence (XigCodec *codec, XigSYNCCreateFence *message)

1713

{

1714

g_signal_emit (codec, signals[SYNC_CREATE_FENCE], 0, message);

1715

}

1716

1717

void

1718

xig_codec_feed_SYNC_trigger_fence (XigCodec *codec, XigSYNCTriggerFence *message)

1719

{

1720

g_signal_emit (codec, signals[SYNC_TRIGGER_FENCE], 0, message);

1721

}

1722

1723

void

1724

xig_codec_feed_SYNC_reset_fence (XigCodec *codec, XigSYNCResetFence *message)

1725

{

1726

g_signal_emit (codec, signals[SYNC_RESET_FENCE], 0, message);

1727

}

1728

1729

void

1730

xig_codec_feed_SYNC_destroy_fence (XigCodec *codec, XigSYNCDestroyFence *message)

1731

{

1732

g_signal_emit (codec, signals[SYNC_DESTROY_FENCE], 0, message);

1733

}

1734

1735

void

1736

xig_codec_feed_SYNC_query_fence (XigCodec *codec, XigSYNCQueryFence *message)

1737

{

1738

g_signal_emit (codec, signals[SYNC_QUERY_FENCE], 0, message);

1739

}

1740

1741

void

1742

xig_codec_feed_SYNC_query_fence_reply (XigCodec *codec, XigSYNCQueryFenceReply *message)

1743

{

1744

g_signal_emit (codec, signals[SYNC_QUERY_FENCE_REPLY], 0, message);

1745

}

1746

1747

void

1748

xig_codec_feed_SYNC_await_fence (XigCodec *codec, XigSYNCAwaitFence *message)

1749

{

1750

g_signal_emit (codec, signals[SYNC_AWAIT_FENCE], 0, message);

1751

}

1752

1753

void

1754

xig_codec_feed_RANDR_screen_change_notify (XigCodec *codec, XigRANDRScreenChangeNotify *message)

1755

{

1756

g_signal_emit (codec, signals[RANDR_SCREEN_CHANGE_NOTIFY], 0, message);

1757

}

1758

1759

void

1760

xig_codec_feed_RANDR_notify (XigCodec *codec, XigRANDRNotify *message)

1761

{

1762

g_signal_emit (codec, signals[RANDR_NOTIFY], 0, message);

1763

}

1764

1765

void

1766

xig_codec_feed_RANDR_query_version (XigCodec *codec, XigRANDRQueryVersion *message)

1767

{

1768

g_signal_emit (codec, signals[RANDR_QUERY_VERSION], 0, message);

1769

}

1770

1771

void

1772

xig_codec_feed_RANDR_query_version_reply (XigCodec *codec, XigRANDRQueryVersionReply *message)

1773

{

1774

g_signal_emit (codec, signals[RANDR_QUERY_VERSION_REPLY], 0, message);

1775

}

1776

1777

void

1778

xig_codec_feed_RANDR_set_screen_config (XigCodec *codec, XigRANDRSetScreenConfig *message)

1779

{

1780

g_signal_emit (codec, signals[RANDR_SET_SCREEN_CONFIG], 0, message);

1781

}

1782

1783

void

1784

xig_codec_feed_RANDR_set_screen_config_reply (XigCodec *codec, XigRANDRSetScreenConfigReply *message)

1785

{

1786

g_signal_emit (codec, signals[RANDR_SET_SCREEN_CONFIG_REPLY], 0, message);

1787

}

1788

1789

void

1790

xig_codec_feed_RANDR_select_input (XigCodec *codec, XigRANDRSelectInput *message)

1791

{

1792

g_signal_emit (codec, signals[RANDR_SELECT_INPUT], 0, message);

1793

}

1794

1795

void

1796

xig_codec_feed_RANDR_get_screen_info (XigCodec *codec, XigRANDRGetScreenInfo *message)

1797

{

1798

g_signal_emit (codec, signals[RANDR_GET_SCREEN_INFO], 0, message);

1799

}

1800

1801

void

1802

xig_codec_feed_RANDR_get_screen_info_reply (XigCodec *codec, XigRANDRGetScreenInfoReply *message)

1803

{

1804

g_signal_emit (codec, signals[RANDR_GET_SCREEN_INFO_REPLY], 0, message);

1805

}

1806

1807

void

1808

xig_codec_feed_RANDR_get_screen_size_range (XigCodec *codec, XigRANDRGetScreenSizeRange *message)

1809

{

1810

g_signal_emit (codec, signals[RANDR_GET_SCREEN_SIZE_RANGE], 0, message);

1811

}

1812

1813

void

1814

xig_codec_feed_RANDR_get_screen_size_range_reply (XigCodec *codec, XigRANDRGetScreenSizeRangeReply *message)

1815

{

1816

g_signal_emit (codec, signals[RANDR_GET_SCREEN_SIZE_RANGE_REPLY], 0, message);

1817

}

1818

1819

void

1820

xig_codec_feed_RANDR_set_screen_size (XigCodec *codec, XigRANDRSetScreenSize *message)

1821

{

1822

g_signal_emit (codec, signals[RANDR_SET_SCREEN_SIZE], 0, message);

1823

}

1824

1825

void

1826

xig_codec_feed_RANDR_get_screen_resources (XigCodec *codec, XigRANDRGetScreenResources *message)

1827

{

1828

g_signal_emit (codec, signals[RANDR_GET_SCREEN_RESOURCES], 0, message);

1829

}

1830

1831

void

1832

xig_codec_feed_RANDR_get_screen_resources_reply (XigCodec *codec, XigRANDRGetScreenResourcesReply *message)

1833

{

1834

g_signal_emit (codec, signals[RANDR_GET_SCREEN_RESOURCES_REPLY], 0, message);

1835

}

1836

1837

void

1838

xig_codec_feed_RANDR_get_output_info (XigCodec *codec, XigRANDRGetOutputInfo *message)

1839

{

1840

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_INFO], 0, message);

1841

}

1842

1843

void

1844

xig_codec_feed_RANDR_get_output_info_reply (XigCodec *codec, XigRANDRGetOutputInfoReply *message)

1845

{

1846

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_INFO_REPLY], 0, message);

1847

}

1848

1849

void

1850

xig_codec_feed_RANDR_list_output_properties (XigCodec *codec, XigRANDRListOutputProperties *message)

1851

{

1852

g_signal_emit (codec, signals[RANDR_LIST_OUTPUT_PROPERTIES], 0, message);

1853

}

1854

1855

void

1856

xig_codec_feed_RANDR_list_output_properties_reply (XigCodec *codec, XigRANDRListOutputPropertiesReply *message)

1857

{

1858

g_signal_emit (codec, signals[RANDR_LIST_OUTPUT_PROPERTIES_REPLY], 0, message);

1859

}

1860

1861

void

1862

xig_codec_feed_RANDR_query_output_property (XigCodec *codec, XigRANDRQueryOutputProperty *message)

1863

{

1864

g_signal_emit (codec, signals[RANDR_QUERY_OUTPUT_PROPERTY], 0, message);

1865

}

1866

1867

void

1868

xig_codec_feed_RANDR_query_output_property_reply (XigCodec *codec, XigRANDRQueryOutputPropertyReply *message)

1869

{

1870

g_signal_emit (codec, signals[RANDR_QUERY_OUTPUT_PROPERTY_REPLY], 0, message);

1871

}

1872

1873

void

1874

xig_codec_feed_RANDR_configure_output_property (XigCodec *codec, XigRANDRConfigureOutputProperty *message)

1875

{

1876

g_signal_emit (codec, signals[RANDR_CONFIGURE_OUTPUT_PROPERTY], 0, message);

1877

}

1878

1879

void

1880

xig_codec_feed_RANDR_change_output_property (XigCodec *codec, XigRANDRChangeOutputProperty *message)

1881

{

1882

g_signal_emit (codec, signals[RANDR_CHANGE_OUTPUT_PROPERTY], 0, message);

1883

}

1884

1885

void

1886

xig_codec_feed_RANDR_delete_output_property (XigCodec *codec, XigRANDRDeleteOutputProperty *message)

1887

{

1888

g_signal_emit (codec, signals[RANDR_DELETE_OUTPUT_PROPERTY], 0, message);

1889

}

1890

1891

void

1892

xig_codec_feed_RANDR_get_output_property (XigCodec *codec, XigRANDRGetOutputProperty *message)

1893

{

1894

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_PROPERTY], 0, message);

1895

}

1896

1897

void

1898

xig_codec_feed_RANDR_get_output_property_reply (XigCodec *codec, XigRANDRGetOutputPropertyReply *message)

1899

{

1900

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_PROPERTY_REPLY], 0, message);

1901

}

1902

1903

void

1904

xig_codec_feed_RANDR_create_mode (XigCodec *codec, XigRANDRCreateMode *message)

1905

{

1906

g_signal_emit (codec, signals[RANDR_CREATE_MODE], 0, message);

1907

}

1908

1909

void

1910

xig_codec_feed_RANDR_create_mode_reply (XigCodec *codec, XigRANDRCreateModeReply *message)

1911

{

1912

g_signal_emit (codec, signals[RANDR_CREATE_MODE_REPLY], 0, message);

1913

}

1914

1915

void

1916

xig_codec_feed_RANDR_destroy_mode (XigCodec *codec, XigRANDRDestroyMode *message)

1917

{

1918

g_signal_emit (codec, signals[RANDR_DESTROY_MODE], 0, message);

1919

}

1920

1921

void

1922

xig_codec_feed_RANDR_add_output_mode (XigCodec *codec, XigRANDRAddOutputMode *message)

1923

{

1924

g_signal_emit (codec, signals[RANDR_ADD_OUTPUT_MODE], 0, message);

1925

}

1926

1927

void

1928

xig_codec_feed_RANDR_delete_output_mode (XigCodec *codec, XigRANDRDeleteOutputMode *message)

1929

{

1930

g_signal_emit (codec, signals[RANDR_DELETE_OUTPUT_MODE], 0, message);

1931

}

1932

1933

void

1934

xig_codec_feed_RANDR_get_crtc_info (XigCodec *codec, XigRANDRGetCrtcInfo *message)

1935

{

1936

g_signal_emit (codec, signals[RANDR_GET_CRTC_INFO], 0, message);

1937

}

1938

1939

void

1940

xig_codec_feed_RANDR_get_crtc_info_reply (XigCodec *codec, XigRANDRGetCrtcInfoReply *message)

1941

{

1942

g_signal_emit (codec, signals[RANDR_GET_CRTC_INFO_REPLY], 0, message);

1943

}

1944

1945

void

1946

xig_codec_feed_RANDR_set_crtc_config (XigCodec *codec, XigRANDRSetCrtcConfig *message)

1947

{

1948

g_signal_emit (codec, signals[RANDR_SET_CRTC_CONFIG], 0, message);

1949

}

1950

1951

void

1952

xig_codec_feed_RANDR_set_crtc_config_reply (XigCodec *codec, XigRANDRSetCrtcConfigReply *message)

1953

{

1954

g_signal_emit (codec, signals[RANDR_SET_CRTC_CONFIG_REPLY], 0, message);

1955

}

1956

1957

void

1958

xig_codec_feed_RANDR_get_crtc_gamma_size (XigCodec *codec, XigRANDRGetCrtcGammaSize *message)

1959

{

1960

g_signal_emit (codec, signals[RANDR_GET_CRTC_GAMMA_SIZE], 0, message);

1961

}

1962

1963

void

1964

xig_codec_feed_RANDR_get_crtc_gamma_size_reply (XigCodec *codec, XigRANDRGetCrtcGammaSizeReply *message)

1965

{

1966

g_signal_emit (codec, signals[RANDR_GET_CRTC_GAMMA_SIZE_REPLY], 0, message);

1967

}

1968

1969

void

1970

xig_codec_feed_RANDR_get_crtc_gamma (XigCodec *codec, XigRANDRGetCrtcGamma *message)

1971

{

1972

g_signal_emit (codec, signals[RANDR_GET_CRTC_GAMMA], 0, message);

1973

}

1974

1975

void

1976

xig_codec_feed_RANDR_get_crtc_gamma_reply (XigCodec *codec, XigRANDRGetCrtcGammaReply *message)

1977

{

1978

g_signal_emit (codec, signals[RANDR_GET_CRTC_GAMMA_REPLY], 0, message);

1979

}

1980

1981

void

1982

xig_codec_feed_RANDR_set_crtc_gamma (XigCodec *codec, XigRANDRSetCrtcGamma *message)

1983

{

1984

g_signal_emit (codec, signals[RANDR_SET_CRTC_GAMMA], 0, message);

1985

}

1986

1987

void

1988

xig_codec_feed_RANDR_get_screen_resources_current (XigCodec *codec, XigRANDRGetScreenResourcesCurrent *message)

1989

{

1990

g_signal_emit (codec, signals[RANDR_GET_SCREEN_RESOURCES_CURRENT], 0, message);

1991

}

1992

1993

void

1994

xig_codec_feed_RANDR_get_screen_resources_current_reply (XigCodec *codec, XigRANDRGetScreenResourcesCurrentReply *message)

1995

{

1996

g_signal_emit (codec, signals[RANDR_GET_SCREEN_RESOURCES_CURRENT_REPLY], 0, message);

1997

}

1998

1999

void

2000

xig_codec_feed_RANDR_set_crtc_transform (XigCodec *codec, XigRANDRSetCrtcTransform *message)

2001

{

2002

g_signal_emit (codec, signals[RANDR_SET_CRTC_TRANSFORM], 0, message);

2003

}

2004

2005

void

2006

xig_codec_feed_RANDR_get_crtc_transform (XigCodec *codec, XigRANDRGetCrtcTransform *message)

2007

{

2008

g_signal_emit (codec, signals[RANDR_GET_CRTC_TRANSFORM], 0, message);

2009

}

2010

2011

void

2012

xig_codec_feed_RANDR_get_crtc_transform_reply (XigCodec *codec, XigRANDRGetCrtcTransformReply *message)

2013

{

2014

g_signal_emit (codec, signals[RANDR_GET_CRTC_TRANSFORM_REPLY], 0, message);

2015

}

2016

2017

void

2018

xig_codec_feed_RANDR_get_panning (XigCodec *codec, XigRANDRGetPanning *message)

2019

{

2020

g_signal_emit (codec, signals[RANDR_GET_PANNING], 0, message);

2021

}

2022

2023

void

2024

xig_codec_feed_RANDR_get_panning_reply (XigCodec *codec, XigRANDRGetPanningReply *message)

2025

{

2026

g_signal_emit (codec, signals[RANDR_GET_PANNING_REPLY], 0, message);

2027

}

2028

2029

void

2030

xig_codec_feed_RANDR_set_panning (XigCodec *codec, XigRANDRSetPanning *message)

2031

{

2032

g_signal_emit (codec, signals[RANDR_SET_PANNING], 0, message);

2033

}

2034

2035

void

2036

xig_codec_feed_RANDR_set_panning_reply (XigCodec *codec, XigRANDRSetPanningReply *message)

2037

{

2038

g_signal_emit (codec, signals[RANDR_SET_PANNING_REPLY], 0, message);

2039

}

2040

2041

void

2042

xig_codec_feed_RANDR_set_output_primary (XigCodec *codec, XigRANDRSetOutputPrimary *message)

2043

{

2044

g_signal_emit (codec, signals[RANDR_SET_OUTPUT_PRIMARY], 0, message);

2045

}

2046

2047

void

2048

xig_codec_feed_RANDR_get_output_primary (XigCodec *codec, XigRANDRGetOutputPrimary *message)

2049

{

2050

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_PRIMARY], 0, message);

2051

}

2052

2053

void

2054

xig_codec_feed_RANDR_get_output_primary_reply (XigCodec *codec, XigRANDRGetOutputPrimaryReply *message)

2055

{

2056

g_signal_emit (codec, signals[RANDR_GET_OUTPUT_PRIMARY_REPLY], 0, message);

2057

}

2058

2059

void

2060

xig_codec_feed_XINERAMA_query_version (XigCodec *codec, XigXINERAMAQueryVersion *message)

2061

{

2062

g_signal_emit (codec, signals[XINERAMA_QUERY_VERSION], 0, message);

2063

}

2064

2065

void

2066

xig_codec_feed_XINERAMA_query_version_reply (XigCodec *codec, XigXINERAMAQueryVersionReply *message)

2067

{

2068

g_signal_emit (codec, signals[XINERAMA_QUERY_VERSION_REPLY], 0, message);

2069

}

2070

2071

void

2072

xig_codec_feed_XINERAMA_get_state (XigCodec *codec, XigXINERAMAGetState *message)

2073

{

2074

g_signal_emit (codec, signals[XINERAMA_GET_STATE], 0, message);

2075

}

2076

2077

void

2078

xig_codec_feed_XINERAMA_get_state_reply (XigCodec *codec, XigXINERAMAGetStateReply *message)

2079

{

2080

g_signal_emit (codec, signals[XINERAMA_GET_STATE_REPLY], 0, message);

2081

}

2082

2083

void

2084

xig_codec_feed_XINERAMA_get_screen_count (XigCodec *codec, XigXINERAMAGetScreenCount *message)

2085

{

2086

g_signal_emit (codec, signals[XINERAMA_GET_SCREEN_COUNT], 0, message);

2087

}

2088

2089

void

2090

xig_codec_feed_XINERAMA_get_screen_count_reply (XigCodec *codec, XigXINERAMAGetScreenCountReply *message)

2091

{

2092

g_signal_emit (codec, signals[XINERAMA_GET_SCREEN_COUNT_REPLY], 0, message);

2093

}

2094

2095

void

2096

xig_codec_feed_XINERAMA_get_screen_size (XigCodec *codec, XigXINERAMAGetScreenSize *message)

2097

{

2098

g_signal_emit (codec, signals[XINERAMA_GET_SCREEN_SIZE], 0, message);

2099

}

2100

2101

void

2102

xig_codec_feed_XINERAMA_get_screen_size_reply (XigCodec *codec, XigXINERAMAGetScreenSizeReply *message)

2103

{

2104

g_signal_emit (codec, signals[XINERAMA_GET_SCREEN_SIZE_REPLY], 0, message);

2105

}

2106

2107

void

2108

xig_codec_feed_XINERAMA_is_active (XigCodec *codec, XigXINERAMAIsActive *message)

2109

{

2110

g_signal_emit (codec, signals[XINERAMA_IS_ACTIVE], 0, message);

2111

}

2112

2113

void

2114

xig_codec_feed_XINERAMA_is_active_reply (XigCodec *codec, XigXINERAMAIsActiveReply *message)

2115

{

2116

g_signal_emit (codec, signals[XINERAMA_IS_ACTIVE_REPLY], 0, message);

2117

}

2118

2119

void

2120

xig_codec_feed_XINERAMA_query_screens (XigCodec *codec, XigXINERAMAQueryScreens *message)

2121

{

2122

g_signal_emit (codec, signals[XINERAMA_QUERY_SCREENS], 0, message);

2123

}

2124

2125

void

2126

xig_codec_feed_XINERAMA_query_screens_reply (XigCodec *codec, XigXINERAMAQueryScreensReply *message)

2127

{

2128

g_signal_emit (codec, signals[XINERAMA_QUERY_SCREENS_REPLY], 0, message);

2129

}

2130

2131

void

2132

xig_codec_feed_XKB_new_keyboard_notify (XigCodec *codec, XigXKBNewKeyboardNotify *message)

2133

{

2134

g_signal_emit (codec, signals[XKB_NEW_KEYBOARD_NOTIFY], 0, message);

2135

}

2136

2137

void

2138

xig_codec_feed_XKB_map_notify (XigCodec *codec, XigXKBMapNotify *message)

2139

{

2140

g_signal_emit (codec, signals[XKB_MAP_NOTIFY], 0, message);

2141

}

2142

2143

void

2144

xig_codec_feed_XKB_state_notify (XigCodec *codec, XigXKBStateNotify *message)

2145

{

2146

g_signal_emit (codec, signals[XKB_STATE_NOTIFY], 0, message);

2147

}

2148

2149

void

2150

xig_codec_feed_XKB_controls_notify (XigCodec *codec, XigXKBControlsNotify *message)

2151

{

2152

g_signal_emit (codec, signals[XKB_CONTROLS_NOTIFY], 0, message);

2153

}

2154

2155

void

2156

xig_codec_feed_XKB_indicator_state_notify (XigCodec *codec, XigXKBIndicatorStateNotify *message)

2157

{

2158

g_signal_emit (codec, signals[XKB_INDICATOR_STATE_NOTIFY], 0, message);

2159

}

2160

2161

void

2162

xig_codec_feed_XKB_indicator_map_notify (XigCodec *codec, XigXKBIndicatorMapNotify *message)

2163

{

2164

g_signal_emit (codec, signals[XKB_INDICATOR_MAP_NOTIFY], 0, message);

2165

}

2166

2167

void

2168

xig_codec_feed_XKB_names_notify (XigCodec *codec, XigXKBNamesNotify *message)

2169

{

2170

g_signal_emit (codec, signals[XKB_NAMES_NOTIFY], 0, message);

2171

}

2172

2173

void

2174

xig_codec_feed_XKB_compat_map_notify (XigCodec *codec, XigXKBCompatMapNotify *message)

2175

{

2176

g_signal_emit (codec, signals[XKB_COMPAT_MAP_NOTIFY], 0, message);

2177

}

2178

2179

void

2180

xig_codec_feed_XKB_bell_notify (XigCodec *codec, XigXKBBellNotify *message)

2181

{

2182

g_signal_emit (codec, signals[XKB_BELL_NOTIFY], 0, message);

2183

}

2184

2185

void

2186

xig_codec_feed_XKB_action_message (XigCodec *codec, XigXKBActionMessage *message)

2187

{

2188

g_signal_emit (codec, signals[XKB_ACTION_MESSAGE], 0, message);

2189

}

2190

2191

void

2192

xig_codec_feed_XKB_access_xnotify (XigCodec *codec, XigXKBAccessXNotify *message)

2193

{

2194

g_signal_emit (codec, signals[XKB_ACCESS_XNOTIFY], 0, message);

2195

}

2196

2197

void

2198

xig_codec_feed_XKB_extension_device_notify (XigCodec *codec, XigXKBExtensionDeviceNotify *message)

2199

{

2200

g_signal_emit (codec, signals[XKB_EXTENSION_DEVICE_NOTIFY], 0, message);

2201

}

2202

2203

void

2204

xig_codec_feed_XKB_use_extension (XigCodec *codec, XigXKBUseExtension *message)

2205

{

2206

g_signal_emit (codec, signals[XKB_USE_EXTENSION], 0, message);

2207

}

2208

2209

void

2210

xig_codec_feed_XKB_use_extension_reply (XigCodec *codec, XigXKBUseExtensionReply *message)

2211

{

2212

g_signal_emit (codec, signals[XKB_USE_EXTENSION_REPLY], 0, message);

2213

}

2214

2215

void

2216

xig_codec_feed_XKB_select_events (XigCodec *codec, XigXKBSelectEvents *message)

2217

{

2218

g_signal_emit (codec, signals[XKB_SELECT_EVENTS], 0, message);

2219

}

2220

2221

void

2222

xig_codec_feed_XKB_bell (XigCodec *codec, XigXKBBell *message)

2223

{

2224

g_signal_emit (codec, signals[XKB_BELL], 0, message);

2225

}

2226

2227

void

2228

xig_codec_feed_XKB_get_state (XigCodec *codec, XigXKBGetState *message)

2229

{

2230

g_signal_emit (codec, signals[XKB_GET_STATE], 0, message);

2231

}

2232

2233

void

2234

xig_codec_feed_XKB_get_state_reply (XigCodec *codec, XigXKBGetStateReply *message)

2235

{

2236

g_signal_emit (codec, signals[XKB_GET_STATE_REPLY], 0, message);

2237

}

2238

2239

void

2240

xig_codec_feed_XKB_latch_lock_state (XigCodec *codec, XigXKBLatchLockState *message)

2241

{

2242

g_signal_emit (codec, signals[XKB_LATCH_LOCK_STATE], 0, message);

2243

}

2244

2245

void

2246

xig_codec_feed_XKB_get_controls (XigCodec *codec, XigXKBGetControls *message)

2247

{

2248

g_signal_emit (codec, signals[XKB_GET_CONTROLS], 0, message);

2249

}

2250

2251

void

2252

xig_codec_feed_XKB_get_controls_reply (XigCodec *codec, XigXKBGetControlsReply *message)

2253

{

2254

g_signal_emit (codec, signals[XKB_GET_CONTROLS_REPLY], 0, message);

2255

}

2256

2257

void

2258

xig_codec_feed_XKB_set_controls (XigCodec *codec, XigXKBSetControls *message)

2259

{

2260

g_signal_emit (codec, signals[XKB_SET_CONTROLS], 0, message);

2261

}

2262

2263

void

2264

xig_codec_feed_XKB_get_map (XigCodec *codec, XigXKBGetMap *message)

2265

{

2266

g_signal_emit (codec, signals[XKB_GET_MAP], 0, message);

2267

}

2268

2269

void

2270

xig_codec_feed_XKB_get_map_reply (XigCodec *codec, XigXKBGetMapReply *message)

2271

{

2272

g_signal_emit (codec, signals[XKB_GET_MAP_REPLY], 0, message);

2273

}

2274

2275

void

2276

xig_codec_feed_XKB_set_map (XigCodec *codec, XigXKBSetMap *message)

2277

{

2278

g_signal_emit (codec, signals[XKB_SET_MAP], 0, message);

2279

}

2280

2281

void

2282

xig_codec_feed_XKB_get_compat_map (XigCodec *codec, XigXKBGetCompatMap *message)

2283

{

2284

g_signal_emit (codec, signals[XKB_GET_COMPAT_MAP], 0, message);

2285

}

2286

2287

void

2288

xig_codec_feed_XKB_get_compat_map_reply (XigCodec *codec, XigXKBGetCompatMapReply *message)

2289

{

2290

g_signal_emit (codec, signals[XKB_GET_COMPAT_MAP_REPLY], 0, message);

2291

}

2292

2293

void

2294

xig_codec_feed_XKB_set_compat_map (XigCodec *codec, XigXKBSetCompatMap *message)

2295

{

2296

g_signal_emit (codec, signals[XKB_SET_COMPAT_MAP], 0, message);

2297

}

2298

2299

void

2300

xig_codec_feed_XKB_get_indicator_state (XigCodec *codec, XigXKBGetIndicatorState *message)

2301

{

2302

g_signal_emit (codec, signals[XKB_GET_INDICATOR_STATE], 0, message);

2303

}

2304

2305

void

2306

xig_codec_feed_XKB_get_indicator_state_reply (XigCodec *codec, XigXKBGetIndicatorStateReply *message)

2307

{

2308

g_signal_emit (codec, signals[XKB_GET_INDICATOR_STATE_REPLY], 0, message);

2309

}

2310

2311

void

2312

xig_codec_feed_XKB_get_indicator_map (XigCodec *codec, XigXKBGetIndicatorMap *message)

2313

{

2314

g_signal_emit (codec, signals[XKB_GET_INDICATOR_MAP], 0, message);

2315

}

2316

2317

void

2318

xig_codec_feed_XKB_get_indicator_map_reply (XigCodec *codec, XigXKBGetIndicatorMapReply *message)

2319

{

2320

g_signal_emit (codec, signals[XKB_GET_INDICATOR_MAP_REPLY], 0, message);

2321

}

2322

2323

void

2324

xig_codec_feed_XKB_set_indicator_map (XigCodec *codec, XigXKBSetIndicatorMap *message)

2325

{

2326

g_signal_emit (codec, signals[XKB_SET_INDICATOR_MAP], 0, message);

2327

}

2328

2329

void

2330

xig_codec_feed_XKB_get_named_indicator (XigCodec *codec, XigXKBGetNamedIndicator *message)

2331

{

2332

g_signal_emit (codec, signals[XKB_GET_NAMED_INDICATOR], 0, message);

2333

}

2334

2335

void

2336

xig_codec_feed_XKB_get_named_indicator_reply (XigCodec *codec, XigXKBGetNamedIndicatorReply *message)

2337

{

2338

g_signal_emit (codec, signals[XKB_GET_NAMED_INDICATOR_REPLY], 0, message);

2339

}

2340

2341

void

2342

xig_codec_feed_XKB_set_named_indicator (XigCodec *codec, XigXKBSetNamedIndicator *message)

2343

{

2344

g_signal_emit (codec, signals[XKB_SET_NAMED_INDICATOR], 0, message);

2345

}

2346

2347

void

2348

xig_codec_feed_XKB_get_names (XigCodec *codec, XigXKBGetNames *message)

2349

{

2350

g_signal_emit (codec, signals[XKB_GET_NAMES], 0, message);

2351

}

2352

2353

void

2354

xig_codec_feed_XKB_get_names_reply (XigCodec *codec, XigXKBGetNamesReply *message)

2355

{

2356

g_signal_emit (codec, signals[XKB_GET_NAMES_REPLY], 0, message);

2357

}

2358

2359

void

2360

xig_codec_feed_XKB_set_names (XigCodec *codec, XigXKBSetNames *message)

2361

{

2362

g_signal_emit (codec, signals[XKB_SET_NAMES], 0, message);

2363

}

2364

2365

void

2366

xig_codec_feed_XKB_get_geometry (XigCodec *codec, XigXKBGetGeometry *message)

2367

{

2368

g_signal_emit (codec, signals[XKB_GET_GEOMETRY], 0, message);

2369

}

2370

2371

void

2372

xig_codec_feed_XKB_get_geometry_reply (XigCodec *codec, XigXKBGetGeometryReply *message)

2373

{

2374

g_signal_emit (codec, signals[XKB_GET_GEOMETRY_REPLY], 0, message);

2375

}

2376

2377

void

2378

xig_codec_feed_XKB_set_geometry (XigCodec *codec, XigXKBSetGeometry *message)

2379

{

2380

g_signal_emit (codec, signals[XKB_SET_GEOMETRY], 0, message);

2381

}

2382

2383

void

2384

xig_codec_feed_XKB_per_client_flags (XigCodec *codec, XigXKBPerClientFlags *message)

2385

{

2386

g_signal_emit (codec, signals[XKB_PER_CLIENT_FLAGS], 0, message);

2387

}

2388

2389

void

2390

xig_codec_feed_XKB_per_client_flags_reply (XigCodec *codec, XigXKBPerClientFlagsReply *message)

2391

{

2392

g_signal_emit (codec, signals[XKB_PER_CLIENT_FLAGS_REPLY], 0, message);

2393

}

2394

2395

void

2396

xig_codec_feed_XKB_list_components (XigCodec *codec, XigXKBListComponents *message)

2397

{

2398

g_signal_emit (codec, signals[XKB_LIST_COMPONENTS], 0, message);

2399

}

2400

2401

void

2402

xig_codec_feed_XKB_list_components_reply (XigCodec *codec, XigXKBListComponentsReply *message)

2403

{

2404

g_signal_emit (codec, signals[XKB_LIST_COMPONENTS_REPLY], 0, message);

2405

}

2406

2407

void

2408

xig_codec_feed_XKB_get_kbd_by_name (XigCodec *codec, XigXKBGetKbdByName *message)

2409

{

2410

g_signal_emit (codec, signals[XKB_GET_KBD_BY_NAME], 0, message);

2411

}

2412

2413

void

2414

xig_codec_feed_XKB_get_kbd_by_name_reply (XigCodec *codec, XigXKBGetKbdByNameReply *message)

2415

{

2416

g_signal_emit (codec, signals[XKB_GET_KBD_BY_NAME_REPLY], 0, message);

2417

}

2418

2419

void

2420

xig_codec_feed_XKB_get_device_info (XigCodec *codec, XigXKBGetDeviceInfo *message)

2421

{

2422

g_signal_emit (codec, signals[XKB_GET_DEVICE_INFO], 0, message);

2423

}

2424

2425

void

2426

xig_codec_feed_XKB_get_device_info_reply (XigCodec *codec, XigXKBGetDeviceInfoReply *message)

2427

{

2428

g_signal_emit (codec, signals[XKB_GET_DEVICE_INFO_REPLY], 0, message);

2429

}

2430

2431

void

2432

xig_codec_feed_XKB_set_device_info (XigCodec *codec, XigXKBSetDeviceInfo *message)

2433

{

2434

g_signal_emit (codec, signals[XKB_SET_DEVICE_INFO], 0, message);

2435

}

2436

2437

void

2438

xig_codec_feed_XKB_set_debugging_flags (XigCodec *codec, XigXKBSetDebuggingFlags *message)

2439

{

2440

g_signal_emit (codec, signals[XKB_SET_DEBUGGING_FLAGS], 0, message);

2441

}

2442

2443

void

2444

xig_codec_feed_XKB_set_debugging_flags_reply (XigCodec *codec, XigXKBSetDebuggingFlagsReply *message)

2445

{

2446

g_signal_emit (codec, signals[XKB_SET_DEBUGGING_FLAGS_REPLY], 0, message);

2447

}

2448

2449

void

2450

xig_codec_feed_RENDER_query_version (XigCodec *codec, XigRENDERQueryVersion *message)

2451

{

2452

g_signal_emit (codec, signals[RENDER_QUERY_VERSION], 0, message);

2453

}

2454

2455

void

2456

xig_codec_feed_RENDER_query_version_reply (XigCodec *codec, XigRENDERQueryVersionReply *message)

2457

{

2458

g_signal_emit (codec, signals[RENDER_QUERY_VERSION_REPLY], 0, message);

2459

}

2460

2461

void

2462

xig_codec_feed_RENDER_query_pict_formats (XigCodec *codec, XigRENDERQueryPictFormats *message)

2463

{

2464

g_signal_emit (codec, signals[RENDER_QUERY_PICT_FORMATS], 0, message);

2465

}

2466

2467

void

2468

xig_codec_feed_RENDER_query_pict_formats_reply (XigCodec *codec, XigRENDERQueryPictFormatsReply *message)

2469

{

2470

g_signal_emit (codec, signals[RENDER_QUERY_PICT_FORMATS_REPLY], 0, message);

2471

}

2472

2473

void

2474

xig_codec_feed_RENDER_query_pict_index_values (XigCodec *codec, XigRENDERQueryPictIndexValues *message)

2475

{

2476

g_signal_emit (codec, signals[RENDER_QUERY_PICT_INDEX_VALUES], 0, message);

2477

}

2478

2479

void

2480

xig_codec_feed_RENDER_query_pict_index_values_reply (XigCodec *codec, XigRENDERQueryPictIndexValuesReply *message)

2481

{

2482

g_signal_emit (codec, signals[RENDER_QUERY_PICT_INDEX_VALUES_REPLY], 0, message);

2483

}

2484

2485

void

2486

xig_codec_feed_RENDER_create_picture (XigCodec *codec, XigRENDERCreatePicture *message)

2487

{

2488

g_signal_emit (codec, signals[RENDER_CREATE_PICTURE], 0, message);

2489

}

2490

2491

void

2492

xig_codec_feed_RENDER_change_picture (XigCodec *codec, XigRENDERChangePicture *message)

2493

{

2494

g_signal_emit (codec, signals[RENDER_CHANGE_PICTURE], 0, message);

2495

}

2496

2497

void

2498

xig_codec_feed_RENDER_set_picture_clip_rectangles (XigCodec *codec, XigRENDERSetPictureClipRectangles *message)

2499

{

2500

g_signal_emit (codec, signals[RENDER_SET_PICTURE_CLIP_RECTANGLES], 0, message);

2501

}

2502

2503

void

2504

xig_codec_feed_RENDER_free_picture (XigCodec *codec, XigRENDERFreePicture *message)

2505

{

2506

g_signal_emit (codec, signals[RENDER_FREE_PICTURE], 0, message);

2507

}

2508

2509

void

2510

xig_codec_feed_RENDER_composite (XigCodec *codec, XigRENDERComposite *message)

2511

{

2512

g_signal_emit (codec, signals[RENDER_COMPOSITE], 0, message);

2513

}

2514

2515

void

2516

xig_codec_feed_RENDER_trapezoids (XigCodec *codec, XigRENDERTrapezoids *message)

2517

{

2518

g_signal_emit (codec, signals[RENDER_TRAPEZOIDS], 0, message);

2519

}

2520

2521

void

2522

xig_codec_feed_RENDER_triangles (XigCodec *codec, XigRENDERTriangles *message)

2523

{

2524

g_signal_emit (codec, signals[RENDER_TRIANGLES], 0, message);

2525

}

2526

2527

void

2528

xig_codec_feed_RENDER_tri_strip (XigCodec *codec, XigRENDERTriStrip *message)

2529

{

2530

g_signal_emit (codec, signals[RENDER_TRI_STRIP], 0, message);

2531

}

2532

2533

void

2534

xig_codec_feed_RENDER_tri_fan (XigCodec *codec, XigRENDERTriFan *message)

2535

{

2536

g_signal_emit (codec, signals[RENDER_TRI_FAN], 0, message);

2537

}

2538

2539

void

2540

xig_codec_feed_RENDER_create_glyph_set (XigCodec *codec, XigRENDERCreateGlyphSet *message)

2541

{

2542

g_signal_emit (codec, signals[RENDER_CREATE_GLYPH_SET], 0, message);

2543

}

2544

2545

void

2546

xig_codec_feed_RENDER_reference_glyph_set (XigCodec *codec, XigRENDERReferenceGlyphSet *message)

2547

{

2548

g_signal_emit (codec, signals[RENDER_REFERENCE_GLYPH_SET], 0, message);

2549

}

2550

2551

void

2552

xig_codec_feed_RENDER_free_glyph_set (XigCodec *codec, XigRENDERFreeGlyphSet *message)

2553

{

2554

g_signal_emit (codec, signals[RENDER_FREE_GLYPH_SET], 0, message);

2555

}

2556

2557

void

2558

xig_codec_feed_RENDER_add_glyphs (XigCodec *codec, XigRENDERAddGlyphs *message)

2559

{

2560

g_signal_emit (codec, signals[RENDER_ADD_GLYPHS], 0, message);

2561

}

2562

2563

void

2564

xig_codec_feed_RENDER_free_glyphs (XigCodec *codec, XigRENDERFreeGlyphs *message)

2565

{

2566

g_signal_emit (codec, signals[RENDER_FREE_GLYPHS], 0, message);

2567

}

2568

2569

void

2570

xig_codec_feed_RENDER_composite_glyphs8 (XigCodec *codec, XigRENDERCompositeGlyphs8 *message)

2571

{

2572

g_signal_emit (codec, signals[RENDER_COMPOSITE_GLYPHS8], 0, message);

2573

}

2574

2575

void

2576

xig_codec_feed_RENDER_composite_glyphs16 (XigCodec *codec, XigRENDERCompositeGlyphs16 *message)

2577

{

2578

g_signal_emit (codec, signals[RENDER_COMPOSITE_GLYPHS16], 0, message);

2579

}

2580

2581

void

2582

xig_codec_feed_RENDER_composite_glyphs32 (XigCodec *codec, XigRENDERCompositeGlyphs32 *message)

2583

{

2584

g_signal_emit (codec, signals[RENDER_COMPOSITE_GLYPHS32], 0, message);

2585

}

2586

2587

void

2588

xig_codec_feed_RENDER_fill_rectangles (XigCodec *codec, XigRENDERFillRectangles *message)

2589

{

2590

g_signal_emit (codec, signals[RENDER_FILL_RECTANGLES], 0, message);

2591

}

2592

2593

void

2594

xig_codec_feed_RENDER_create_cursor (XigCodec *codec, XigRENDERCreateCursor *message)

2595

{

2596

g_signal_emit (codec, signals[RENDER_CREATE_CURSOR], 0, message);

2597

}

2598

2599

void

2600

xig_codec_feed_RENDER_set_picture_transform (XigCodec *codec, XigRENDERSetPictureTransform *message)

2601

{

2602

g_signal_emit (codec, signals[RENDER_SET_PICTURE_TRANSFORM], 0, message);

2603

}

2604

2605

void

2606

xig_codec_feed_RENDER_query_filters (XigCodec *codec, XigRENDERQueryFilters *message)

2607

{

2608

g_signal_emit (codec, signals[RENDER_QUERY_FILTERS], 0, message);

2609

}

2610

2611

void

2612

xig_codec_feed_RENDER_query_filters_reply (XigCodec *codec, XigRENDERQueryFiltersReply *message)

2613

{

2614

g_signal_emit (codec, signals[RENDER_QUERY_FILTERS_REPLY], 0, message);

2615

}

2616

2617

void

2618

xig_codec_feed_RENDER_set_picture_filter (XigCodec *codec, XigRENDERSetPictureFilter *message)

2619

{

2620

g_signal_emit (codec, signals[RENDER_SET_PICTURE_FILTER], 0, message);

2621

}

2622

2623

void

2624

xig_codec_feed_RENDER_create_anim_cursor (XigCodec *codec, XigRENDERCreateAnimCursor *message)

2625

{

2626

g_signal_emit (codec, signals[RENDER_CREATE_ANIM_CURSOR], 0, message);

2627

}

2628

2629

void

2630

xig_codec_feed_RENDER_add_traps (XigCodec *codec, XigRENDERAddTraps *message)

2631

{

2632

g_signal_emit (codec, signals[RENDER_ADD_TRAPS], 0, message);

2633

}

2634

2635

void

2636

xig_codec_feed_RENDER_create_solid_fill (XigCodec *codec, XigRENDERCreateSolidFill *message)

2637

{

2638

g_signal_emit (codec, signals[RENDER_CREATE_SOLID_FILL], 0, message);

2639

}

2640

2641

void

2642

xig_codec_feed_RENDER_create_linear_gradient (XigCodec *codec, XigRENDERCreateLinearGradient *message)

2643

{

2644

g_signal_emit (codec, signals[RENDER_CREATE_LINEAR_GRADIENT], 0, message);

2645

}

2646

2647

void

2648

xig_codec_feed_RENDER_create_radial_gradient (XigCodec *codec, XigRENDERCreateRadialGradient *message)

2649

{

2650

g_signal_emit (codec, signals[RENDER_CREATE_RADIAL_GRADIENT], 0, message);

2651

}

2652

2653

void

2654

xig_codec_feed_RENDER_create_conical_gradient (XigCodec *codec, XigRENDERCreateConicalGradient *message)

2655

{

2656

g_signal_emit (codec, signals[RENDER_CREATE_CONICAL_GRADIENT], 0, message);

2657

}

2658

2659

static void

2660

xig_codec_real_feed_data (XigCodec *codec, const guint8 *data, gsize data_length)

2661

{

2662

}

2663

2664

static void

2665

xig_codec_real_write (XigCodec *codec, const guint8 *data, gsize data_length)

2666

{

2667

}

2668

2669

static void

2670

xig_codec_init (XigCodec *codec)

2671

{

2672

}

2673

2674

static void

2675

xig_codec_class_init (XigCodecClass *klass)

2676

{

2677

klass->feed_data = xig_codec_real_feed_data;

2678

klass->write = xig_codec_real_write;

2679

2680

signals[CONNECT] =

2681

g_signal_new ("connect",

2682

G_TYPE_FROM_CLASS (klass),

2683

G_SIGNAL_RUN_LAST,

2684

G_STRUCT_OFFSET (XigCodecClass, connect),

2685

NULL, NULL,

2686

g_cclosure_marshal_VOID__POINTER,

2687

G_TYPE_NONE, 1, G_TYPE_POINTER);

2688

signals[FAILED] =

2689

g_signal_new ("failed",

2690

G_TYPE_FROM_CLASS (klass),

2691

G_SIGNAL_RUN_LAST,

2692

G_STRUCT_OFFSET (XigCodecClass, failed),

2693

NULL, NULL,

2694

g_cclosure_marshal_VOID__POINTER,

2695

G_TYPE_NONE, 1, G_TYPE_POINTER);

2696

signals[AUTHENTICATE] =

2697

g_signal_new ("authenticate",

2698

G_TYPE_FROM_CLASS (klass),

2699

G_SIGNAL_RUN_LAST,

2700

G_STRUCT_OFFSET (XigCodecClass, authenticate),

2701

NULL, NULL,

2702

g_cclosure_marshal_VOID__POINTER,

2703

G_TYPE_NONE, 1, G_TYPE_POINTER);

2704

signals[SUCCESS] =

2705

g_signal_new ("success",

2706

G_TYPE_FROM_CLASS (klass),

2707

G_SIGNAL_RUN_LAST,

2708

G_STRUCT_OFFSET (XigCodecClass, success),

2709

NULL, NULL,

2710

g_cclosure_marshal_VOID__POINTER,

2711

G_TYPE_NONE, 1, G_TYPE_POINTER);

2712

signals[ERROR] =

2713

g_signal_new ("error",

2714

G_TYPE_FROM_CLASS (klass),

2715

G_SIGNAL_RUN_LAST,

2716

G_STRUCT_OFFSET (XigCodecClass, error),

2717

NULL, NULL,

2718

g_cclosure_marshal_VOID__POINTER,

2719

G_TYPE_NONE, 1, G_TYPE_POINTER);

2720

signals[KEY_PRESS] =

2721

g_signal_new ("key-press",

2722

G_TYPE_FROM_CLASS (klass),

2723

G_SIGNAL_RUN_LAST,

2724

G_STRUCT_OFFSET (XigCodecClass, key_press),

2725

NULL, NULL,

2726

g_cclosure_marshal_VOID__POINTER,

2727

G_TYPE_NONE, 1, G_TYPE_POINTER);

2728

signals[BUTTON_PRESS] =

2729

g_signal_new ("button-press",

2730

G_TYPE_FROM_CLASS (klass),

2731

G_SIGNAL_RUN_LAST,

2732

G_STRUCT_OFFSET (XigCodecClass, button_press),

2733

NULL, NULL,

2734

g_cclosure_marshal_VOID__POINTER,

2735

G_TYPE_NONE, 1, G_TYPE_POINTER);

2736

signals[MOTION_NOTIFY] =

2737

g_signal_new ("motion-notify",

2738

G_TYPE_FROM_CLASS (klass),

2739

G_SIGNAL_RUN_LAST,

2740

G_STRUCT_OFFSET (XigCodecClass, motion_notify),

2741

NULL, NULL,

2742

g_cclosure_marshal_VOID__POINTER,

2743

G_TYPE_NONE, 1, G_TYPE_POINTER);

2744

signals[ENTER_NOTIFY] =

2745

g_signal_new ("enter-notify",

2746

G_TYPE_FROM_CLASS (klass),

2747

G_SIGNAL_RUN_LAST,

2748

G_STRUCT_OFFSET (XigCodecClass, enter_notify),

2749

NULL, NULL,

2750

g_cclosure_marshal_VOID__POINTER,

2751

G_TYPE_NONE, 1, G_TYPE_POINTER);

2752

signals[FOCUS_IN] =

2753

g_signal_new ("focus-in",

2754

G_TYPE_FROM_CLASS (klass),

2755

G_SIGNAL_RUN_LAST,

2756

G_STRUCT_OFFSET (XigCodecClass, focus_in),

2757

NULL, NULL,

2758

g_cclosure_marshal_VOID__POINTER,

2759

G_TYPE_NONE, 1, G_TYPE_POINTER);

2760

signals[KEYMAP_NOTIFY] =

2761

g_signal_new ("keymap-notify",

2762

G_TYPE_FROM_CLASS (klass),

2763

G_SIGNAL_RUN_LAST,

2764

G_STRUCT_OFFSET (XigCodecClass, keymap_notify),

2765

NULL, NULL,

2766

g_cclosure_marshal_VOID__POINTER,

2767

G_TYPE_NONE, 1, G_TYPE_POINTER);

2768

signals[EXPOSE] =

2769

g_signal_new ("expose",

2770

G_TYPE_FROM_CLASS (klass),

2771

G_SIGNAL_RUN_LAST,

2772

G_STRUCT_OFFSET (XigCodecClass, expose),

2773

NULL, NULL,

2774

g_cclosure_marshal_VOID__POINTER,

2775

G_TYPE_NONE, 1, G_TYPE_POINTER);

2776

signals[GRAPHICS_EXPOSURE] =

2777

g_signal_new ("graphics-exposure",

2778

G_TYPE_FROM_CLASS (klass),

2779

G_SIGNAL_RUN_LAST,

2780

G_STRUCT_OFFSET (XigCodecClass, graphics_exposure),

2781

NULL, NULL,

2782

g_cclosure_marshal_VOID__POINTER,

2783

G_TYPE_NONE, 1, G_TYPE_POINTER);

2784

signals[NO_EXPOSURE] =

2785

g_signal_new ("no-exposure",

2786

G_TYPE_FROM_CLASS (klass),

2787

G_SIGNAL_RUN_LAST,

2788

G_STRUCT_OFFSET (XigCodecClass, no_exposure),

2789

NULL, NULL,

2790

g_cclosure_marshal_VOID__POINTER,

2791

G_TYPE_NONE, 1, G_TYPE_POINTER);

2792

signals[VISIBILITY_NOTIFY] =

2793

g_signal_new ("visibility-notify",

2794

G_TYPE_FROM_CLASS (klass),

2795

G_SIGNAL_RUN_LAST,

2796

G_STRUCT_OFFSET (XigCodecClass, visibility_notify),

2797

NULL, NULL,

2798

g_cclosure_marshal_VOID__POINTER,

2799

G_TYPE_NONE, 1, G_TYPE_POINTER);

2800

signals[CREATE_NOTIFY] =

2801

g_signal_new ("create-notify",

2802

G_TYPE_FROM_CLASS (klass),

2803

G_SIGNAL_RUN_LAST,

2804

G_STRUCT_OFFSET (XigCodecClass, create_notify),

2805

NULL, NULL,

2806

g_cclosure_marshal_VOID__POINTER,

2807

G_TYPE_NONE, 1, G_TYPE_POINTER);

2808

signals[DESTROY_NOTIFY] =

2809

g_signal_new ("destroy-notify",

2810

G_TYPE_FROM_CLASS (klass),

2811

G_SIGNAL_RUN_LAST,

2812

G_STRUCT_OFFSET (XigCodecClass, destroy_notify),

2813

NULL, NULL,

2814

g_cclosure_marshal_VOID__POINTER,

2815

G_TYPE_NONE, 1, G_TYPE_POINTER);

2816

signals[UNMAP_NOTIFY] =

2817

g_signal_new ("unmap-notify",

2818

G_TYPE_FROM_CLASS (klass),

2819

G_SIGNAL_RUN_LAST,

2820

G_STRUCT_OFFSET (XigCodecClass, unmap_notify),

2821

NULL, NULL,

2822

g_cclosure_marshal_VOID__POINTER,

2823

G_TYPE_NONE, 1, G_TYPE_POINTER);

2824

signals[MAP_NOTIFY] =

2825

g_signal_new ("map-notify",

2826

G_TYPE_FROM_CLASS (klass),

2827

G_SIGNAL_RUN_LAST,

2828

G_STRUCT_OFFSET (XigCodecClass, map_notify),

2829

NULL, NULL,

2830

g_cclosure_marshal_VOID__POINTER,

2831

G_TYPE_NONE, 1, G_TYPE_POINTER);

2832

signals[MAP_REQUEST] =

2833

g_signal_new ("map-request",

2834

G_TYPE_FROM_CLASS (klass),

2835

G_SIGNAL_RUN_LAST,

2836

G_STRUCT_OFFSET (XigCodecClass, map_request),

2837

NULL, NULL,

2838

g_cclosure_marshal_VOID__POINTER,

2839

G_TYPE_NONE, 1, G_TYPE_POINTER);

2840

signals[REPARENT_NOTIFY] =

2841

g_signal_new ("reparent-notify",

2842

G_TYPE_FROM_CLASS (klass),

2843

G_SIGNAL_RUN_LAST,

2844

G_STRUCT_OFFSET (XigCodecClass, reparent_notify),

2845

NULL, NULL,

2846

g_cclosure_marshal_VOID__POINTER,

2847

G_TYPE_NONE, 1, G_TYPE_POINTER);

2848

signals[CONFIGURE_NOTIFY] =

2849

g_signal_new ("configure-notify",

2850

G_TYPE_FROM_CLASS (klass),

2851

G_SIGNAL_RUN_LAST,

2852

G_STRUCT_OFFSET (XigCodecClass, configure_notify),

2853

NULL, NULL,

2854

g_cclosure_marshal_VOID__POINTER,

2855

G_TYPE_NONE, 1, G_TYPE_POINTER);

2856

signals[CONFIGURE_REQUEST] =

2857

g_signal_new ("configure-request",

2858

G_TYPE_FROM_CLASS (klass),

2859

G_SIGNAL_RUN_LAST,

2860

G_STRUCT_OFFSET (XigCodecClass, configure_request),

2861

NULL, NULL,

2862

g_cclosure_marshal_VOID__POINTER,

2863

G_TYPE_NONE, 1, G_TYPE_POINTER);

2864

signals[GRAVITY_NOTIFY] =

2865

g_signal_new ("gravity-notify",

2866

G_TYPE_FROM_CLASS (klass),

2867

G_SIGNAL_RUN_LAST,

2868

G_STRUCT_OFFSET (XigCodecClass, gravity_notify),

2869

NULL, NULL,

2870

g_cclosure_marshal_VOID__POINTER,

2871

G_TYPE_NONE, 1, G_TYPE_POINTER);

2872

signals[RESIZE_REQUEST] =

2873

g_signal_new ("resize-request",

2874

G_TYPE_FROM_CLASS (klass),

2875

G_SIGNAL_RUN_LAST,

2876

G_STRUCT_OFFSET (XigCodecClass, resize_request),

2877

NULL, NULL,

2878

g_cclosure_marshal_VOID__POINTER,

2879

G_TYPE_NONE, 1, G_TYPE_POINTER);

2880

signals[CIRCULATE_NOTIFY] =

2881

g_signal_new ("circulate-notify",

2882

G_TYPE_FROM_CLASS (klass),

2883

G_SIGNAL_RUN_LAST,

2884

G_STRUCT_OFFSET (XigCodecClass, circulate_notify),

2885

NULL, NULL,

2886

g_cclosure_marshal_VOID__POINTER,

2887

G_TYPE_NONE, 1, G_TYPE_POINTER);

2888

signals[CIRCULATE_REQUEST] =

2889

g_signal_new ("circulate-request",

2890

G_TYPE_FROM_CLASS (klass),

2891

G_SIGNAL_RUN_LAST,

2892

G_STRUCT_OFFSET (XigCodecClass, circulate_request),

2893

NULL, NULL,

2894

g_cclosure_marshal_VOID__POINTER,

2895

G_TYPE_NONE, 1, G_TYPE_POINTER);

2896

signals[PROPERTY_NOTIFY] =

2897

g_signal_new ("property-notify",

2898

G_TYPE_FROM_CLASS (klass),

2899

G_SIGNAL_RUN_LAST,

2900

G_STRUCT_OFFSET (XigCodecClass, property_notify),

2901

NULL, NULL,

2902

g_cclosure_marshal_VOID__POINTER,

2903

G_TYPE_NONE, 1, G_TYPE_POINTER);

2904

signals[SELECTION_CLEAR] =

2905

g_signal_new ("selection-clear",

2906

G_TYPE_FROM_CLASS (klass),

2907

G_SIGNAL_RUN_LAST,

2908

G_STRUCT_OFFSET (XigCodecClass, selection_clear),

2909

NULL, NULL,

2910

g_cclosure_marshal_VOID__POINTER,

2911

G_TYPE_NONE, 1, G_TYPE_POINTER);

2912

signals[SELECTION_REQUEST] =

2913

g_signal_new ("selection-request",

2914

G_TYPE_FROM_CLASS (klass),

2915

G_SIGNAL_RUN_LAST,

2916

G_STRUCT_OFFSET (XigCodecClass, selection_request),

2917

NULL, NULL,

2918

g_cclosure_marshal_VOID__POINTER,

2919

G_TYPE_NONE, 1, G_TYPE_POINTER);

2920

signals[SELECTION_NOTIFY] =

2921

g_signal_new ("selection-notify",

2922

G_TYPE_FROM_CLASS (klass),

2923

G_SIGNAL_RUN_LAST,

2924

G_STRUCT_OFFSET (XigCodecClass, selection_notify),

2925

NULL, NULL,

2926

g_cclosure_marshal_VOID__POINTER,

2927

G_TYPE_NONE, 1, G_TYPE_POINTER);

2928

signals[COLORMAP_NOTIFY] =

2929

g_signal_new ("colormap-notify",

2930

G_TYPE_FROM_CLASS (klass),

2931

G_SIGNAL_RUN_LAST,

2932

G_STRUCT_OFFSET (XigCodecClass, colormap_notify),

2933

NULL, NULL,

2934

g_cclosure_marshal_VOID__POINTER,

2935

G_TYPE_NONE, 1, G_TYPE_POINTER);

2936

signals[CLIENT_MESSAGE] =

2937

g_signal_new ("client-message",

2938

G_TYPE_FROM_CLASS (klass),

2939

G_SIGNAL_RUN_LAST,

2940

G_STRUCT_OFFSET (XigCodecClass, client_message),

2941

NULL, NULL,

2942

g_cclosure_marshal_VOID__POINTER,

2943

G_TYPE_NONE, 1, G_TYPE_POINTER);

2944

signals[MAPPING_NOTIFY] =

2945

g_signal_new ("mapping-notify",

2946

G_TYPE_FROM_CLASS (klass),

2947

G_SIGNAL_RUN_LAST,

2948

G_STRUCT_OFFSET (XigCodecClass, mapping_notify),

2949

NULL, NULL,

2950

g_cclosure_marshal_VOID__POINTER,

2951

G_TYPE_NONE, 1, G_TYPE_POINTER);

2952

signals[CREATE_WINDOW] =

2953

g_signal_new ("create-window",

2954

G_TYPE_FROM_CLASS (klass),

2955

G_SIGNAL_RUN_LAST,

2956

G_STRUCT_OFFSET (XigCodecClass, create_window),

2957

NULL, NULL,

2958

g_cclosure_marshal_VOID__POINTER,

2959

G_TYPE_NONE, 1, G_TYPE_POINTER);

2960

signals[CHANGE_WINDOW_ATTRIBUTES] =

2961

g_signal_new ("change-window-attributes",

2962

G_TYPE_FROM_CLASS (klass),

2963

G_SIGNAL_RUN_LAST,

2964

G_STRUCT_OFFSET (XigCodecClass, change_window_attributes),

2965

NULL, NULL,

2966

g_cclosure_marshal_VOID__POINTER,

2967

G_TYPE_NONE, 1, G_TYPE_POINTER);

2968

signals[GET_WINDOW_ATTRIBUTES] =

2969

g_signal_new ("get-window-attributes",

2970

G_TYPE_FROM_CLASS (klass),

2971

G_SIGNAL_RUN_LAST,

2972

G_STRUCT_OFFSET (XigCodecClass, get_window_attributes),

2973

NULL, NULL,

2974

g_cclosure_marshal_VOID__POINTER,

2975

G_TYPE_NONE, 1, G_TYPE_POINTER);

2976

signals[GET_WINDOW_ATTRIBUTES_REPLY] =

2977

g_signal_new ("get-window-attributes-reply",

2978

G_TYPE_FROM_CLASS (klass),

2979

G_SIGNAL_RUN_LAST,

2980

G_STRUCT_OFFSET (XigCodecClass, get_window_attributes_reply),

2981

NULL, NULL,

2982

g_cclosure_marshal_VOID__POINTER,

2983

G_TYPE_NONE, 1, G_TYPE_POINTER);

2984

signals[DESTROY_WINDOW] =

2985

g_signal_new ("destroy-window",

2986

G_TYPE_FROM_CLASS (klass),

2987

G_SIGNAL_RUN_LAST,

2988

G_STRUCT_OFFSET (XigCodecClass, destroy_window),

2989

NULL, NULL,

2990

g_cclosure_marshal_VOID__POINTER,

2991

G_TYPE_NONE, 1, G_TYPE_POINTER);

2992

signals[DESTROY_SUBWINDOWS] =

2993

g_signal_new ("destroy-subwindows",

2994

G_TYPE_FROM_CLASS (klass),

2995

G_SIGNAL_RUN_LAST,

2996

G_STRUCT_OFFSET (XigCodecClass, destroy_subwindows),

2997

NULL, NULL,

2998

g_cclosure_marshal_VOID__POINTER,

2999

G_TYPE_NONE, 1, G_TYPE_POINTER);

3000

signals[CHANGE_SAVE_SET] =

3001

g_signal_new ("change-save-set",

3002

G_TYPE_FROM_CLASS (klass),

3003

G_SIGNAL_RUN_LAST,

3004

G_STRUCT_OFFSET (XigCodecClass, change_save_set),

3005

NULL, NULL,

3006

g_cclosure_marshal_VOID__POINTER,

3007

G_TYPE_NONE, 1, G_TYPE_POINTER);

3008

signals[REPARENT_WINDOW] =

3009

g_signal_new ("reparent-window",

3010

G_TYPE_FROM_CLASS (klass),

3011

G_SIGNAL_RUN_LAST,

3012

G_STRUCT_OFFSET (XigCodecClass, reparent_window),

3013

NULL, NULL,

3014

g_cclosure_marshal_VOID__POINTER,

3015

G_TYPE_NONE, 1, G_TYPE_POINTER);

3016

signals[MAP_WINDOW] =

3017

g_signal_new ("map-window",

3018

G_TYPE_FROM_CLASS (klass),

3019

G_SIGNAL_RUN_LAST,

3020

G_STRUCT_OFFSET (XigCodecClass, map_window),

3021

NULL, NULL,

3022

g_cclosure_marshal_VOID__POINTER,

3023

G_TYPE_NONE, 1, G_TYPE_POINTER);

3024

signals[MAP_SUBWINDOWS] =

3025

g_signal_new ("map-subwindows",

3026

G_TYPE_FROM_CLASS (klass),

3027

G_SIGNAL_RUN_LAST,

3028

G_STRUCT_OFFSET (XigCodecClass, map_subwindows),

3029

NULL, NULL,

3030

g_cclosure_marshal_VOID__POINTER,

3031

G_TYPE_NONE, 1, G_TYPE_POINTER);

3032

signals[UNMAP_WINDOW] =

3033

g_signal_new ("unmap-window",

3034

G_TYPE_FROM_CLASS (klass),

3035

G_SIGNAL_RUN_LAST,

3036

G_STRUCT_OFFSET (XigCodecClass, unmap_window),

3037

NULL, NULL,

3038

g_cclosure_marshal_VOID__POINTER,

3039

G_TYPE_NONE, 1, G_TYPE_POINTER);

3040

signals[UNMAP_SUBWINDOWS] =

3041

g_signal_new ("unmap-subwindows",

3042

G_TYPE_FROM_CLASS (klass),

3043

G_SIGNAL_RUN_LAST,

3044

G_STRUCT_OFFSET (XigCodecClass, unmap_subwindows),

3045

NULL, NULL,

3046

g_cclosure_marshal_VOID__POINTER,

3047

G_TYPE_NONE, 1, G_TYPE_POINTER);

3048

signals[CONFIGURE_WINDOW] =

3049

g_signal_new ("configure-window",

3050

G_TYPE_FROM_CLASS (klass),

3051

G_SIGNAL_RUN_LAST,

3052

G_STRUCT_OFFSET (XigCodecClass, configure_window),

3053

NULL, NULL,

3054

g_cclosure_marshal_VOID__POINTER,

3055

G_TYPE_NONE, 1, G_TYPE_POINTER);

3056

signals[CIRCULATE_WINDOW] =

3057

g_signal_new ("circulate-window",

3058

G_TYPE_FROM_CLASS (klass),

3059

G_SIGNAL_RUN_LAST,

3060

G_STRUCT_OFFSET (XigCodecClass, circulate_window),

3061

NULL, NULL,

3062

g_cclosure_marshal_VOID__POINTER,

3063

G_TYPE_NONE, 1, G_TYPE_POINTER);

3064

signals[GET_GEOMETRY] =

3065

g_signal_new ("get-geometry",

3066

G_TYPE_FROM_CLASS (klass),

3067

G_SIGNAL_RUN_LAST,

3068

G_STRUCT_OFFSET (XigCodecClass, get_geometry),

3069

NULL, NULL,

3070

g_cclosure_marshal_VOID__POINTER,

3071

G_TYPE_NONE, 1, G_TYPE_POINTER);

3072

signals[GET_GEOMETRY_REPLY] =

3073

g_signal_new ("get-geometry-reply",

3074

G_TYPE_FROM_CLASS (klass),

3075

G_SIGNAL_RUN_LAST,

3076

G_STRUCT_OFFSET (XigCodecClass, get_geometry_reply),

3077

NULL, NULL,

3078

g_cclosure_marshal_VOID__POINTER,

3079

G_TYPE_NONE, 1, G_TYPE_POINTER);

3080

signals[QUERY_TREE] =

3081

g_signal_new ("query-tree",

3082

G_TYPE_FROM_CLASS (klass),

3083

G_SIGNAL_RUN_LAST,

3084

G_STRUCT_OFFSET (XigCodecClass, query_tree),

3085

NULL, NULL,

3086

g_cclosure_marshal_VOID__POINTER,

3087

G_TYPE_NONE, 1, G_TYPE_POINTER);

3088

signals[QUERY_TREE_REPLY] =

3089

g_signal_new ("query-tree-reply",

3090

G_TYPE_FROM_CLASS (klass),

3091

G_SIGNAL_RUN_LAST,

3092

G_STRUCT_OFFSET (XigCodecClass, query_tree_reply),

3093

NULL, NULL,

3094

g_cclosure_marshal_VOID__POINTER,

3095

G_TYPE_NONE, 1, G_TYPE_POINTER);

3096

signals[INTERN_ATOM] =

3097

g_signal_new ("intern-atom",

3098

G_TYPE_FROM_CLASS (klass),

3099

G_SIGNAL_RUN_LAST,

3100

G_STRUCT_OFFSET (XigCodecClass, intern_atom),

3101

NULL, NULL,

3102

g_cclosure_marshal_VOID__POINTER,

3103

G_TYPE_NONE, 1, G_TYPE_POINTER);

3104

signals[INTERN_ATOM_REPLY] =

3105

g_signal_new ("intern-atom-reply",

3106

G_TYPE_FROM_CLASS (klass),

3107

G_SIGNAL_RUN_LAST,

3108

G_STRUCT_OFFSET (XigCodecClass, intern_atom_reply),

3109

NULL, NULL,

3110

g_cclosure_marshal_VOID__POINTER,

3111

G_TYPE_NONE, 1, G_TYPE_POINTER);

3112

signals[GET_ATOM_NAME] =

3113

g_signal_new ("get-atom-name",

3114

G_TYPE_FROM_CLASS (klass),

3115

G_SIGNAL_RUN_LAST,

3116

G_STRUCT_OFFSET (XigCodecClass, get_atom_name),

3117

NULL, NULL,

3118

g_cclosure_marshal_VOID__POINTER,

3119

G_TYPE_NONE, 1, G_TYPE_POINTER);

3120

signals[GET_ATOM_NAME_REPLY] =

3121

g_signal_new ("get-atom-name-reply",

3122

G_TYPE_FROM_CLASS (klass),

3123

G_SIGNAL_RUN_LAST,

3124

G_STRUCT_OFFSET (XigCodecClass, get_atom_name_reply),

3125

NULL, NULL,

3126

g_cclosure_marshal_VOID__POINTER,

3127

G_TYPE_NONE, 1, G_TYPE_POINTER);

3128

signals[CHANGE_PROPERTY] =

3129

g_signal_new ("change-property",

3130

G_TYPE_FROM_CLASS (klass),

3131

G_SIGNAL_RUN_LAST,

3132

G_STRUCT_OFFSET (XigCodecClass, change_property),

3133

NULL, NULL,

3134

g_cclosure_marshal_VOID__POINTER,

3135

G_TYPE_NONE, 1, G_TYPE_POINTER);

3136

signals[DELETE_PROPERTY] =

3137

g_signal_new ("delete-property",

3138

G_TYPE_FROM_CLASS (klass),

3139

G_SIGNAL_RUN_LAST,

3140

G_STRUCT_OFFSET (XigCodecClass, delete_property),

3141

NULL, NULL,

3142

g_cclosure_marshal_VOID__POINTER,

3143

G_TYPE_NONE, 1, G_TYPE_POINTER);

3144

signals[GET_PROPERTY] =

3145

g_signal_new ("get-property",

3146

G_TYPE_FROM_CLASS (klass),

3147

G_SIGNAL_RUN_LAST,

3148

G_STRUCT_OFFSET (XigCodecClass, get_property),

3149

NULL, NULL,

3150

g_cclosure_marshal_VOID__POINTER,

3151

G_TYPE_NONE, 1, G_TYPE_POINTER);

3152

signals[GET_PROPERTY_REPLY] =

3153

g_signal_new ("get-property-reply",

3154

G_TYPE_FROM_CLASS (klass),

3155

G_SIGNAL_RUN_LAST,

3156

G_STRUCT_OFFSET (XigCodecClass, get_property_reply),

3157

NULL, NULL,

3158

g_cclosure_marshal_VOID__POINTER,

3159

G_TYPE_NONE, 1, G_TYPE_POINTER);

3160

signals[LIST_PROPERTIES] =

3161

g_signal_new ("list-properties",

3162

G_TYPE_FROM_CLASS (klass),

3163

G_SIGNAL_RUN_LAST,

3164

G_STRUCT_OFFSET (XigCodecClass, list_properties),

3165

NULL, NULL,

3166

g_cclosure_marshal_VOID__POINTER,

3167

G_TYPE_NONE, 1, G_TYPE_POINTER);

3168

signals[LIST_PROPERTIES_REPLY] =

3169

g_signal_new ("list-properties-reply",

3170

G_TYPE_FROM_CLASS (klass),

3171

G_SIGNAL_RUN_LAST,

3172

G_STRUCT_OFFSET (XigCodecClass, list_properties_reply),

3173

NULL, NULL,

3174

g_cclosure_marshal_VOID__POINTER,

3175

G_TYPE_NONE, 1, G_TYPE_POINTER);

3176

signals[SET_SELECTION_OWNER] =

3177

g_signal_new ("set-selection-owner",

3178

G_TYPE_FROM_CLASS (klass),

3179

G_SIGNAL_RUN_LAST,

3180

G_STRUCT_OFFSET (XigCodecClass, set_selection_owner),

3181

NULL, NULL,

3182

g_cclosure_marshal_VOID__POINTER,

3183

G_TYPE_NONE, 1, G_TYPE_POINTER);

3184

signals[GET_SELECTION_OWNER] =

3185

g_signal_new ("get-selection-owner",

3186

G_TYPE_FROM_CLASS (klass),

3187

G_SIGNAL_RUN_LAST,

3188

G_STRUCT_OFFSET (XigCodecClass, get_selection_owner),

3189

NULL, NULL,

3190

g_cclosure_marshal_VOID__POINTER,

3191

G_TYPE_NONE, 1, G_TYPE_POINTER);

3192

signals[GET_SELECTION_OWNER_REPLY] =

3193

g_signal_new ("get-selection-owner-reply",

3194

G_TYPE_FROM_CLASS (klass),

3195

G_SIGNAL_RUN_LAST,

3196

G_STRUCT_OFFSET (XigCodecClass, get_selection_owner_reply),

3197

NULL, NULL,

3198

g_cclosure_marshal_VOID__POINTER,

3199

G_TYPE_NONE, 1, G_TYPE_POINTER);

3200

signals[CONVERT_SELECTION] =

3201

g_signal_new ("convert-selection",

3202

G_TYPE_FROM_CLASS (klass),

3203

G_SIGNAL_RUN_LAST,

3204

G_STRUCT_OFFSET (XigCodecClass, convert_selection),

3205

NULL, NULL,

3206

g_cclosure_marshal_VOID__POINTER,

3207

G_TYPE_NONE, 1, G_TYPE_POINTER);

3208

signals[SEND_EVENT] =

3209

g_signal_new ("send-event",

3210

G_TYPE_FROM_CLASS (klass),

3211

G_SIGNAL_RUN_LAST,

3212

G_STRUCT_OFFSET (XigCodecClass, send_event),

3213

NULL, NULL,

3214

g_cclosure_marshal_VOID__POINTER,

3215

G_TYPE_NONE, 1, G_TYPE_POINTER);

3216

signals[GRAB_POINTER] =

3217

g_signal_new ("grab-pointer",

3218

G_TYPE_FROM_CLASS (klass),

3219

G_SIGNAL_RUN_LAST,

3220

G_STRUCT_OFFSET (XigCodecClass, grab_pointer),

3221

NULL, NULL,

3222

g_cclosure_marshal_VOID__POINTER,

3223

G_TYPE_NONE, 1, G_TYPE_POINTER);

3224

signals[GRAB_POINTER_REPLY] =

3225

g_signal_new ("grab-pointer-reply",

3226

G_TYPE_FROM_CLASS (klass),

3227

G_SIGNAL_RUN_LAST,

3228

G_STRUCT_OFFSET (XigCodecClass, grab_pointer_reply),

3229

NULL, NULL,

3230

g_cclosure_marshal_VOID__POINTER,

3231

G_TYPE_NONE, 1, G_TYPE_POINTER);

3232

signals[UNGRAB_POINTER] =

3233

g_signal_new ("ungrab-pointer",

3234

G_TYPE_FROM_CLASS (klass),

3235

G_SIGNAL_RUN_LAST,

3236

G_STRUCT_OFFSET (XigCodecClass, ungrab_pointer),

3237

NULL, NULL,

3238

g_cclosure_marshal_VOID__POINTER,

3239

G_TYPE_NONE, 1, G_TYPE_POINTER);

3240

signals[GRAB_BUTTON] =

3241

g_signal_new ("grab-button",

3242

G_TYPE_FROM_CLASS (klass),

3243

G_SIGNAL_RUN_LAST,

3244

G_STRUCT_OFFSET (XigCodecClass, grab_button),

3245

NULL, NULL,

3246

g_cclosure_marshal_VOID__POINTER,

3247

G_TYPE_NONE, 1, G_TYPE_POINTER);

3248

signals[UNGRAB_BUTTON] =

3249

g_signal_new ("ungrab-button",

3250

G_TYPE_FROM_CLASS (klass),

3251

G_SIGNAL_RUN_LAST,

3252

G_STRUCT_OFFSET (XigCodecClass, ungrab_button),

3253

NULL, NULL,

3254

g_cclosure_marshal_VOID__POINTER,

3255

G_TYPE_NONE, 1, G_TYPE_POINTER);

3256

signals[CHANGE_ACTIVE_POINTER_GRAB] =

3257

g_signal_new ("change-active-pointer-grab",

3258

G_TYPE_FROM_CLASS (klass),

3259

G_SIGNAL_RUN_LAST,

3260

G_STRUCT_OFFSET (XigCodecClass, change_active_pointer_grab),

3261

NULL, NULL,

3262

g_cclosure_marshal_VOID__POINTER,

3263

G_TYPE_NONE, 1, G_TYPE_POINTER);

3264

signals[GRAB_KEYBOARD] =

3265

g_signal_new ("grab-keyboard",

3266

G_TYPE_FROM_CLASS (klass),

3267

G_SIGNAL_RUN_LAST,

3268

G_STRUCT_OFFSET (XigCodecClass, grab_keyboard),

3269

NULL, NULL,

3270

g_cclosure_marshal_VOID__POINTER,

3271

G_TYPE_NONE, 1, G_TYPE_POINTER);

3272

signals[GRAB_KEYBOARD_REPLY] =

3273

g_signal_new ("grab-keyboard-reply",

3274

G_TYPE_FROM_CLASS (klass),

3275

G_SIGNAL_RUN_LAST,

3276

G_STRUCT_OFFSET (XigCodecClass, grab_keyboard_reply),

3277

NULL, NULL,

3278

g_cclosure_marshal_VOID__POINTER,

3279

G_TYPE_NONE, 1, G_TYPE_POINTER);

3280

signals[UNGRAB_KEYBOARD] =

3281

g_signal_new ("ungrab-keyboard",

3282

G_TYPE_FROM_CLASS (klass),

3283

G_SIGNAL_RUN_LAST,

3284

G_STRUCT_OFFSET (XigCodecClass, ungrab_keyboard),

3285

NULL, NULL,

3286

g_cclosure_marshal_VOID__POINTER,

3287

G_TYPE_NONE, 1, G_TYPE_POINTER);

3288

signals[GRAB_KEY] =

3289

g_signal_new ("grab-key",

3290

G_TYPE_FROM_CLASS (klass),

3291

G_SIGNAL_RUN_LAST,

3292

G_STRUCT_OFFSET (XigCodecClass, grab_key),

3293

NULL, NULL,

3294

g_cclosure_marshal_VOID__POINTER,

3295

G_TYPE_NONE, 1, G_TYPE_POINTER);

3296

signals[UNGRAB_KEY] =

3297

g_signal_new ("ungrab-key",

3298

G_TYPE_FROM_CLASS (klass),

3299

G_SIGNAL_RUN_LAST,

3300

G_STRUCT_OFFSET (XigCodecClass, ungrab_key),

3301

NULL, NULL,

3302

g_cclosure_marshal_VOID__POINTER,

3303

G_TYPE_NONE, 1, G_TYPE_POINTER);

3304

signals[ALLOW_EVENTS] =

3305

g_signal_new ("allow-events",

3306

G_TYPE_FROM_CLASS (klass),

3307

G_SIGNAL_RUN_LAST,

3308

G_STRUCT_OFFSET (XigCodecClass, allow_events),

3309

NULL, NULL,

3310

g_cclosure_marshal_VOID__POINTER,

3311

G_TYPE_NONE, 1, G_TYPE_POINTER);

3312

signals[GRAB_SERVER] =

3313

g_signal_new ("grab-server",

3314

G_TYPE_FROM_CLASS (klass),

3315

G_SIGNAL_RUN_LAST,

3316

G_STRUCT_OFFSET (XigCodecClass, grab_server),

3317

NULL, NULL,

3318

g_cclosure_marshal_VOID__POINTER,

3319

G_TYPE_NONE, 1, G_TYPE_POINTER);

3320

signals[UNGRAB_SERVER] =

3321

g_signal_new ("ungrab-server",

3322

G_TYPE_FROM_CLASS (klass),

3323

G_SIGNAL_RUN_LAST,

3324

G_STRUCT_OFFSET (XigCodecClass, ungrab_server),

3325

NULL, NULL,

3326

g_cclosure_marshal_VOID__POINTER,

3327

G_TYPE_NONE, 1, G_TYPE_POINTER);

3328

signals[QUERY_POINTER] =

3329

g_signal_new ("query-pointer",

3330

G_TYPE_FROM_CLASS (klass),

3331

G_SIGNAL_RUN_LAST,

3332

G_STRUCT_OFFSET (XigCodecClass, query_pointer),

3333

NULL, NULL,

3334

g_cclosure_marshal_VOID__POINTER,

3335

G_TYPE_NONE, 1, G_TYPE_POINTER);

3336

signals[QUERY_POINTER_REPLY] =

3337

g_signal_new ("query-pointer-reply",

3338

G_TYPE_FROM_CLASS (klass),

3339

G_SIGNAL_RUN_LAST,

3340

G_STRUCT_OFFSET (XigCodecClass, query_pointer_reply),

3341

NULL, NULL,

3342

g_cclosure_marshal_VOID__POINTER,

3343

G_TYPE_NONE, 1, G_TYPE_POINTER);

3344

signals[GET_MOTION_EVENTS] =

3345

g_signal_new ("get-motion-events",

3346

G_TYPE_FROM_CLASS (klass),

3347

G_SIGNAL_RUN_LAST,

3348

G_STRUCT_OFFSET (XigCodecClass, get_motion_events),

3349

NULL, NULL,

3350

g_cclosure_marshal_VOID__POINTER,

3351

G_TYPE_NONE, 1, G_TYPE_POINTER);

3352

signals[GET_MOTION_EVENTS_REPLY] =

3353

g_signal_new ("get-motion-events-reply",

3354

G_TYPE_FROM_CLASS (klass),

3355

G_SIGNAL_RUN_LAST,

3356

G_STRUCT_OFFSET (XigCodecClass, get_motion_events_reply),

3357

NULL, NULL,

3358

g_cclosure_marshal_VOID__POINTER,

3359

G_TYPE_NONE, 1, G_TYPE_POINTER);

3360

signals[TRANSLATE_COORDINATES] =

3361

g_signal_new ("translate-coordinates",

3362

G_TYPE_FROM_CLASS (klass),

3363

G_SIGNAL_RUN_LAST,

3364

G_STRUCT_OFFSET (XigCodecClass, translate_coordinates),

3365

NULL, NULL,

3366

g_cclosure_marshal_VOID__POINTER,

3367

G_TYPE_NONE, 1, G_TYPE_POINTER);

3368

signals[TRANSLATE_COORDINATES_REPLY] =

3369

g_signal_new ("translate-coordinates-reply",

3370

G_TYPE_FROM_CLASS (klass),

3371

G_SIGNAL_RUN_LAST,

3372

G_STRUCT_OFFSET (XigCodecClass, translate_coordinates_reply),

3373

NULL, NULL,

3374

g_cclosure_marshal_VOID__POINTER,

3375

G_TYPE_NONE, 1, G_TYPE_POINTER);

3376

signals[WARP_POINTER] =

3377

g_signal_new ("warp-pointer",

3378

G_TYPE_FROM_CLASS (klass),

3379

G_SIGNAL_RUN_LAST,

3380

G_STRUCT_OFFSET (XigCodecClass, warp_pointer),

3381

NULL, NULL,

3382

g_cclosure_marshal_VOID__POINTER,

3383

G_TYPE_NONE, 1, G_TYPE_POINTER);

3384

signals[SET_INPUT_FOCUS] =

3385

g_signal_new ("set-input-focus",

3386

G_TYPE_FROM_CLASS (klass),

3387

G_SIGNAL_RUN_LAST,

3388

G_STRUCT_OFFSET (XigCodecClass, set_input_focus),

3389

NULL, NULL,

3390

g_cclosure_marshal_VOID__POINTER,

3391

G_TYPE_NONE, 1, G_TYPE_POINTER);

3392

signals[GET_INPUT_FOCUS] =

3393

g_signal_new ("get-input-focus",

3394

G_TYPE_FROM_CLASS (klass),

3395

G_SIGNAL_RUN_LAST,

3396

G_STRUCT_OFFSET (XigCodecClass, get_input_focus),

3397

NULL, NULL,

3398

g_cclosure_marshal_VOID__POINTER,

3399

G_TYPE_NONE, 1, G_TYPE_POINTER);

3400

signals[GET_INPUT_FOCUS_REPLY] =

3401

g_signal_new ("get-input-focus-reply",

3402

G_TYPE_FROM_CLASS (klass),

3403

G_SIGNAL_RUN_LAST,

3404

G_STRUCT_OFFSET (XigCodecClass, get_input_focus_reply),

3405

NULL, NULL,

3406

g_cclosure_marshal_VOID__POINTER,

3407

G_TYPE_NONE, 1, G_TYPE_POINTER);

3408

signals[QUERY_KEYMAP] =

3409

g_signal_new ("query-keymap",

3410

G_TYPE_FROM_CLASS (klass),

3411

G_SIGNAL_RUN_LAST,

3412

G_STRUCT_OFFSET (XigCodecClass, query_keymap),

3413

NULL, NULL,

3414

g_cclosure_marshal_VOID__POINTER,

3415

G_TYPE_NONE, 1, G_TYPE_POINTER);

3416

signals[QUERY_KEYMAP_REPLY] =

3417

g_signal_new ("query-keymap-reply",

3418

G_TYPE_FROM_CLASS (klass),

3419

G_SIGNAL_RUN_LAST,

3420

G_STRUCT_OFFSET (XigCodecClass, query_keymap_reply),

3421

NULL, NULL,

3422

g_cclosure_marshal_VOID__POINTER,

3423

G_TYPE_NONE, 1, G_TYPE_POINTER);

3424

signals[OPEN_FONT] =

3425

g_signal_new ("open-font",

3426

G_TYPE_FROM_CLASS (klass),

3427

G_SIGNAL_RUN_LAST,

3428

G_STRUCT_OFFSET (XigCodecClass, open_font),

3429

NULL, NULL,

3430

g_cclosure_marshal_VOID__POINTER,

3431

G_TYPE_NONE, 1, G_TYPE_POINTER);

3432

signals[CLOSE_FONT] =

3433

g_signal_new ("close-font",

3434

G_TYPE_FROM_CLASS (klass),

3435

G_SIGNAL_RUN_LAST,

3436

G_STRUCT_OFFSET (XigCodecClass, close_font),

3437

NULL, NULL,

3438

g_cclosure_marshal_VOID__POINTER,

3439

G_TYPE_NONE, 1, G_TYPE_POINTER);

3440

signals[QUERY_FONT] =

3441

g_signal_new ("query-font",

3442

G_TYPE_FROM_CLASS (klass),

3443

G_SIGNAL_RUN_LAST,

3444

G_STRUCT_OFFSET (XigCodecClass, query_font),

3445

NULL, NULL,

3446

g_cclosure_marshal_VOID__POINTER,

3447

G_TYPE_NONE, 1, G_TYPE_POINTER);

3448

signals[QUERY_FONT_REPLY] =

3449

g_signal_new ("query-font-reply",

3450

G_TYPE_FROM_CLASS (klass),

3451

G_SIGNAL_RUN_LAST,

3452

G_STRUCT_OFFSET (XigCodecClass, query_font_reply),

3453

NULL, NULL,

3454

g_cclosure_marshal_VOID__POINTER,

3455

G_TYPE_NONE, 1, G_TYPE_POINTER);

3456

signals[QUERY_TEXT_EXTENTS] =

3457

g_signal_new ("query-text-extents",

3458

G_TYPE_FROM_CLASS (klass),

3459

G_SIGNAL_RUN_LAST,

3460

G_STRUCT_OFFSET (XigCodecClass, query_text_extents),

3461

NULL, NULL,

3462

g_cclosure_marshal_VOID__POINTER,

3463

G_TYPE_NONE, 1, G_TYPE_POINTER);

3464

signals[QUERY_TEXT_EXTENTS_REPLY] =

3465

g_signal_new ("query-text-extents-reply",

3466

G_TYPE_FROM_CLASS (klass),

3467

G_SIGNAL_RUN_LAST,

3468

G_STRUCT_OFFSET (XigCodecClass, query_text_extents_reply),

3469

NULL, NULL,

3470

g_cclosure_marshal_VOID__POINTER,

3471

G_TYPE_NONE, 1, G_TYPE_POINTER);

3472

signals[LIST_FONTS] =

3473

g_signal_new ("list-fonts",

3474

G_TYPE_FROM_CLASS (klass),

3475

G_SIGNAL_RUN_LAST,

3476

G_STRUCT_OFFSET (XigCodecClass, list_fonts),

3477

NULL, NULL,

3478

g_cclosure_marshal_VOID__POINTER,

3479

G_TYPE_NONE, 1, G_TYPE_POINTER);

3480

signals[LIST_FONTS_REPLY] =

3481

g_signal_new ("list-fonts-reply",

3482

G_TYPE_FROM_CLASS (klass),

3483

G_SIGNAL_RUN_LAST,

3484

G_STRUCT_OFFSET (XigCodecClass, list_fonts_reply),

3485

NULL, NULL,

3486

g_cclosure_marshal_VOID__POINTER,

3487

G_TYPE_NONE, 1, G_TYPE_POINTER);

3488

signals[LIST_FONTS_WITH_INFO] =

3489

g_signal_new ("list-fonts-with-info",

3490

G_TYPE_FROM_CLASS (klass),

3491

G_SIGNAL_RUN_LAST,

3492

G_STRUCT_OFFSET (XigCodecClass, list_fonts_with_info),

3493

NULL, NULL,

3494

g_cclosure_marshal_VOID__POINTER,

3495

G_TYPE_NONE, 1, G_TYPE_POINTER);

3496

signals[LIST_FONTS_WITH_INFO_REPLY] =

3497

g_signal_new ("list-fonts-with-info-reply",

3498

G_TYPE_FROM_CLASS (klass),

3499

G_SIGNAL_RUN_LAST,

3500

G_STRUCT_OFFSET (XigCodecClass, list_fonts_with_info_reply),

3501

NULL, NULL,

3502

g_cclosure_marshal_VOID__POINTER,

3503

G_TYPE_NONE, 1, G_TYPE_POINTER);

3504

signals[SET_FONT_PATH] =

3505

g_signal_new ("set-font-path",

3506

G_TYPE_FROM_CLASS (klass),

3507

G_SIGNAL_RUN_LAST,

3508

G_STRUCT_OFFSET (XigCodecClass, set_font_path),

3509

NULL, NULL,

3510

g_cclosure_marshal_VOID__POINTER,

3511

G_TYPE_NONE, 1, G_TYPE_POINTER);

3512

signals[GET_FONT_PATH] =

3513

g_signal_new ("get-font-path",

3514

G_TYPE_FROM_CLASS (klass),

3515

G_SIGNAL_RUN_LAST,

3516

G_STRUCT_OFFSET (XigCodecClass, get_font_path),

3517

NULL, NULL,

3518

g_cclosure_marshal_VOID__POINTER,

3519

G_TYPE_NONE, 1, G_TYPE_POINTER);

3520

signals[GET_FONT_PATH_REPLY] =

3521

g_signal_new ("get-font-path-reply",

3522

G_TYPE_FROM_CLASS (klass),

3523

G_SIGNAL_RUN_LAST,

3524

G_STRUCT_OFFSET (XigCodecClass, get_font_path_reply),

3525

NULL, NULL,

3526

g_cclosure_marshal_VOID__POINTER,

3527

G_TYPE_NONE, 1, G_TYPE_POINTER);

3528

signals[CREATE_PIXMAP] =

3529

g_signal_new ("create-pixmap",

3530

G_TYPE_FROM_CLASS (klass),

3531

G_SIGNAL_RUN_LAST,

3532

G_STRUCT_OFFSET (XigCodecClass, create_pixmap),

3533

NULL, NULL,

3534

g_cclosure_marshal_VOID__POINTER,

3535

G_TYPE_NONE, 1, G_TYPE_POINTER);

3536

signals[FREE_PIXMAP] =

3537

g_signal_new ("free-pixmap",

3538

G_TYPE_FROM_CLASS (klass),

3539

G_SIGNAL_RUN_LAST,

3540

G_STRUCT_OFFSET (XigCodecClass, free_pixmap),

3541

NULL, NULL,

3542

g_cclosure_marshal_VOID__POINTER,

3543

G_TYPE_NONE, 1, G_TYPE_POINTER);

3544

signals[CREATE_GC] =

3545

g_signal_new ("create-gc",

3546

G_TYPE_FROM_CLASS (klass),

3547

G_SIGNAL_RUN_LAST,

3548

G_STRUCT_OFFSET (XigCodecClass, create_gc),

3549

NULL, NULL,

3550

g_cclosure_marshal_VOID__POINTER,

3551

G_TYPE_NONE, 1, G_TYPE_POINTER);

3552

signals[CHANGE_GC] =

3553

g_signal_new ("change-gc",

3554

G_TYPE_FROM_CLASS (klass),

3555

G_SIGNAL_RUN_LAST,

3556

G_STRUCT_OFFSET (XigCodecClass, change_gc),

3557

NULL, NULL,

3558

g_cclosure_marshal_VOID__POINTER,

3559

G_TYPE_NONE, 1, G_TYPE_POINTER);

3560

signals[COPY_GC] =

3561

g_signal_new ("copy-gc",

3562

G_TYPE_FROM_CLASS (klass),

3563

G_SIGNAL_RUN_LAST,

3564

G_STRUCT_OFFSET (XigCodecClass, copy_gc),

3565

NULL, NULL,

3566

g_cclosure_marshal_VOID__POINTER,

3567

G_TYPE_NONE, 1, G_TYPE_POINTER);

3568

signals[SET_DASHES] =

3569

g_signal_new ("set-dashes",

3570

G_TYPE_FROM_CLASS (klass),

3571

G_SIGNAL_RUN_LAST,

3572

G_STRUCT_OFFSET (XigCodecClass, set_dashes),

3573

NULL, NULL,

3574

g_cclosure_marshal_VOID__POINTER,

3575

G_TYPE_NONE, 1, G_TYPE_POINTER);

3576

signals[SET_CLIP_RECTANGLES] =

3577

g_signal_new ("set-clip-rectangles",

3578

G_TYPE_FROM_CLASS (klass),

3579

G_SIGNAL_RUN_LAST,

3580

G_STRUCT_OFFSET (XigCodecClass, set_clip_rectangles),

3581

NULL, NULL,

3582

g_cclosure_marshal_VOID__POINTER,

3583

G_TYPE_NONE, 1, G_TYPE_POINTER);

3584

signals[FREE_GC] =

3585

g_signal_new ("free-gc",

3586

G_TYPE_FROM_CLASS (klass),

3587

G_SIGNAL_RUN_LAST,

3588

G_STRUCT_OFFSET (XigCodecClass, free_gc),

3589

NULL, NULL,

3590

g_cclosure_marshal_VOID__POINTER,

3591

G_TYPE_NONE, 1, G_TYPE_POINTER);

3592

signals[CLEAR_AREA] =

3593

g_signal_new ("clear-area",

3594

G_TYPE_FROM_CLASS (klass),

3595

G_SIGNAL_RUN_LAST,

3596

G_STRUCT_OFFSET (XigCodecClass, clear_area),

3597

NULL, NULL,

3598

g_cclosure_marshal_VOID__POINTER,

3599

G_TYPE_NONE, 1, G_TYPE_POINTER);

3600

signals[COPY_AREA] =

3601

g_signal_new ("copy-area",

3602

G_TYPE_FROM_CLASS (klass),

3603

G_SIGNAL_RUN_LAST,

3604

G_STRUCT_OFFSET (XigCodecClass, copy_area),

3605

NULL, NULL,

3606

g_cclosure_marshal_VOID__POINTER,

3607

G_TYPE_NONE, 1, G_TYPE_POINTER);

3608

signals[COPY_PLANE] =

3609

g_signal_new ("copy-plane",

3610

G_TYPE_FROM_CLASS (klass),

3611

G_SIGNAL_RUN_LAST,

3612

G_STRUCT_OFFSET (XigCodecClass, copy_plane),

3613

NULL, NULL,

3614

g_cclosure_marshal_VOID__POINTER,

3615

G_TYPE_NONE, 1, G_TYPE_POINTER);

3616

signals[POLY_POINT] =

3617

g_signal_new ("poly-point",

3618

G_TYPE_FROM_CLASS (klass),

3619

G_SIGNAL_RUN_LAST,

3620

G_STRUCT_OFFSET (XigCodecClass, poly_point),

3621

NULL, NULL,

3622

g_cclosure_marshal_VOID__POINTER,

3623

G_TYPE_NONE, 1, G_TYPE_POINTER);

3624

signals[POLY_LINE] =

3625

g_signal_new ("poly-line",

3626

G_TYPE_FROM_CLASS (klass),

3627

G_SIGNAL_RUN_LAST,

3628

G_STRUCT_OFFSET (XigCodecClass, poly_line),

3629

NULL, NULL,

3630

g_cclosure_marshal_VOID__POINTER,

3631

G_TYPE_NONE, 1, G_TYPE_POINTER);

3632

signals[POLY_SEGMENT] =

3633

g_signal_new ("poly-segment",

3634

G_TYPE_FROM_CLASS (klass),

3635

G_SIGNAL_RUN_LAST,

3636

G_STRUCT_OFFSET (XigCodecClass, poly_segment),

3637

NULL, NULL,

3638

g_cclosure_marshal_VOID__POINTER,

3639

G_TYPE_NONE, 1, G_TYPE_POINTER);

3640

signals[POLY_RECTANGLE] =

3641

g_signal_new ("poly-rectangle",

3642

G_TYPE_FROM_CLASS (klass),

3643

G_SIGNAL_RUN_LAST,

3644

G_STRUCT_OFFSET (XigCodecClass, poly_rectangle),

3645

NULL, NULL,

3646

g_cclosure_marshal_VOID__POINTER,

3647

G_TYPE_NONE, 1, G_TYPE_POINTER);

3648

signals[POLY_ARC] =

3649

g_signal_new ("poly-arc",

3650

G_TYPE_FROM_CLASS (klass),

3651

G_SIGNAL_RUN_LAST,

3652

G_STRUCT_OFFSET (XigCodecClass, poly_arc),

3653

NULL, NULL,

3654

g_cclosure_marshal_VOID__POINTER,

3655

G_TYPE_NONE, 1, G_TYPE_POINTER);

3656

signals[FILL_POLY] =

3657

g_signal_new ("fill-poly",

3658

G_TYPE_FROM_CLASS (klass),

3659

G_SIGNAL_RUN_LAST,

3660

G_STRUCT_OFFSET (XigCodecClass, fill_poly),

3661

NULL, NULL,

3662

g_cclosure_marshal_VOID__POINTER,

3663

G_TYPE_NONE, 1, G_TYPE_POINTER);

3664

signals[POLY_FILL_RECTANGLE] =

3665

g_signal_new ("poly-fill-rectangle",

3666

G_TYPE_FROM_CLASS (klass),

3667

G_SIGNAL_RUN_LAST,

3668

G_STRUCT_OFFSET (XigCodecClass, poly_fill_rectangle),

3669

NULL, NULL,

3670

g_cclosure_marshal_VOID__POINTER,

3671

G_TYPE_NONE, 1, G_TYPE_POINTER);

3672

signals[POLY_FILL_ARC] =

3673

g_signal_new ("poly-fill-arc",

3674

G_TYPE_FROM_CLASS (klass),

3675

G_SIGNAL_RUN_LAST,

3676

G_STRUCT_OFFSET (XigCodecClass, poly_fill_arc),

3677

NULL, NULL,

3678

g_cclosure_marshal_VOID__POINTER,

3679

G_TYPE_NONE, 1, G_TYPE_POINTER);

3680

signals[PUT_IMAGE] =

3681

g_signal_new ("put-image",

3682

G_TYPE_FROM_CLASS (klass),

3683

G_SIGNAL_RUN_LAST,

3684

G_STRUCT_OFFSET (XigCodecClass, put_image),

3685

NULL, NULL,

3686

g_cclosure_marshal_VOID__POINTER,

3687

G_TYPE_NONE, 1, G_TYPE_POINTER);

3688

signals[GET_IMAGE] =

3689

g_signal_new ("get-image",

3690

G_TYPE_FROM_CLASS (klass),

3691

G_SIGNAL_RUN_LAST,

3692

G_STRUCT_OFFSET (XigCodecClass, get_image),

3693

NULL, NULL,

3694

g_cclosure_marshal_VOID__POINTER,

3695

G_TYPE_NONE, 1, G_TYPE_POINTER);

3696

signals[GET_IMAGE_REPLY] =

3697

g_signal_new ("get-image-reply",

3698

G_TYPE_FROM_CLASS (klass),

3699

G_SIGNAL_RUN_LAST,

3700

G_STRUCT_OFFSET (XigCodecClass, get_image_reply),

3701

NULL, NULL,

3702

g_cclosure_marshal_VOID__POINTER,

3703

G_TYPE_NONE, 1, G_TYPE_POINTER);

3704

signals[POLY_TEXT8] =

3705

g_signal_new ("poly-text8",

3706

G_TYPE_FROM_CLASS (klass),

3707

G_SIGNAL_RUN_LAST,

3708

G_STRUCT_OFFSET (XigCodecClass, poly_text8),

3709

NULL, NULL,

3710

g_cclosure_marshal_VOID__POINTER,

3711

G_TYPE_NONE, 1, G_TYPE_POINTER);

3712

signals[POLY_TEXT16] =

3713

g_signal_new ("poly-text16",

3714

G_TYPE_FROM_CLASS (klass),

3715

G_SIGNAL_RUN_LAST,

3716

G_STRUCT_OFFSET (XigCodecClass, poly_text16),

3717

NULL, NULL,

3718

g_cclosure_marshal_VOID__POINTER,

3719

G_TYPE_NONE, 1, G_TYPE_POINTER);

3720

signals[IMAGE_TEXT8] =

3721

g_signal_new ("image-text8",

3722

G_TYPE_FROM_CLASS (klass),

3723

G_SIGNAL_RUN_LAST,

3724

G_STRUCT_OFFSET (XigCodecClass, image_text8),

3725

NULL, NULL,

3726

g_cclosure_marshal_VOID__POINTER,

3727

G_TYPE_NONE, 1, G_TYPE_POINTER);

3728

signals[IMAGE_TEXT16] =

3729

g_signal_new ("image-text16",

3730

G_TYPE_FROM_CLASS (klass),

3731

G_SIGNAL_RUN_LAST,

3732

G_STRUCT_OFFSET (XigCodecClass, image_text16),

3733

NULL, NULL,

3734

g_cclosure_marshal_VOID__POINTER,

3735

G_TYPE_NONE, 1, G_TYPE_POINTER);

3736

signals[CREATE_COLORMAP] =

3737

g_signal_new ("create-colormap",

3738

G_TYPE_FROM_CLASS (klass),

3739

G_SIGNAL_RUN_LAST,

3740

G_STRUCT_OFFSET (XigCodecClass, create_colormap),

3741

NULL, NULL,

3742

g_cclosure_marshal_VOID__POINTER,

3743

G_TYPE_NONE, 1, G_TYPE_POINTER);

3744

signals[FREE_COLORMAP] =

3745

g_signal_new ("free-colormap",

3746

G_TYPE_FROM_CLASS (klass),

3747

G_SIGNAL_RUN_LAST,

3748

G_STRUCT_OFFSET (XigCodecClass, free_colormap),

3749

NULL, NULL,

3750

g_cclosure_marshal_VOID__POINTER,

3751

G_TYPE_NONE, 1, G_TYPE_POINTER);

3752

signals[COPY_COLORMAP_AND_FREE] =

3753

g_signal_new ("copy-colormap-and-free",

3754

G_TYPE_FROM_CLASS (klass),

3755

G_SIGNAL_RUN_LAST,

3756

G_STRUCT_OFFSET (XigCodecClass, copy_colormap_and_free),

3757

NULL, NULL,

3758

g_cclosure_marshal_VOID__POINTER,

3759

G_TYPE_NONE, 1, G_TYPE_POINTER);

3760

signals[INSTALL_COLORMAP] =

3761

g_signal_new ("install-colormap",

3762

G_TYPE_FROM_CLASS (klass),

3763

G_SIGNAL_RUN_LAST,

3764

G_STRUCT_OFFSET (XigCodecClass, install_colormap),

3765

NULL, NULL,

3766

g_cclosure_marshal_VOID__POINTER,

3767

G_TYPE_NONE, 1, G_TYPE_POINTER);

3768

signals[UNINSTALL_COLORMAP] =

3769

g_signal_new ("uninstall-colormap",

3770

G_TYPE_FROM_CLASS (klass),

3771

G_SIGNAL_RUN_LAST,

3772

G_STRUCT_OFFSET (XigCodecClass, uninstall_colormap),

3773

NULL, NULL,

3774

g_cclosure_marshal_VOID__POINTER,

3775

G_TYPE_NONE, 1, G_TYPE_POINTER);

3776

signals[LIST_INSTALLED_COLORMAPS] =

3777

g_signal_new ("list-installed-colormaps",

3778

G_TYPE_FROM_CLASS (klass),

3779

G_SIGNAL_RUN_LAST,

3780

G_STRUCT_OFFSET (XigCodecClass, list_installed_colormaps),

3781

NULL, NULL,

3782

g_cclosure_marshal_VOID__POINTER,

3783

G_TYPE_NONE, 1, G_TYPE_POINTER);

3784

signals[LIST_INSTALLED_COLORMAPS_REPLY] =

3785

g_signal_new ("list-installed-colormaps-reply",

3786

G_TYPE_FROM_CLASS (klass),

3787

G_SIGNAL_RUN_LAST,

3788

G_STRUCT_OFFSET (XigCodecClass, list_installed_colormaps_reply),

3789

NULL, NULL,

3790

g_cclosure_marshal_VOID__POINTER,

3791

G_TYPE_NONE, 1, G_TYPE_POINTER);

3792

signals[ALLOC_COLOR] =

3793

g_signal_new ("alloc-color",

3794

G_TYPE_FROM_CLASS (klass),

3795

G_SIGNAL_RUN_LAST,

3796

G_STRUCT_OFFSET (XigCodecClass, alloc_color),

3797

NULL, NULL,

3798

g_cclosure_marshal_VOID__POINTER,

3799

G_TYPE_NONE, 1, G_TYPE_POINTER);

3800

signals[ALLOC_COLOR_REPLY] =

3801

g_signal_new ("alloc-color-reply",

3802

G_TYPE_FROM_CLASS (klass),

3803

G_SIGNAL_RUN_LAST,

3804

G_STRUCT_OFFSET (XigCodecClass, alloc_color_reply),

3805

NULL, NULL,

3806

g_cclosure_marshal_VOID__POINTER,

3807

G_TYPE_NONE, 1, G_TYPE_POINTER);

3808

signals[ALLOC_NAMED_COLOR] =

3809

g_signal_new ("alloc-named-color",

3810

G_TYPE_FROM_CLASS (klass),

3811

G_SIGNAL_RUN_LAST,

3812

G_STRUCT_OFFSET (XigCodecClass, alloc_named_color),

3813

NULL, NULL,

3814

g_cclosure_marshal_VOID__POINTER,

3815

G_TYPE_NONE, 1, G_TYPE_POINTER);

3816

signals[ALLOC_NAMED_COLOR_REPLY] =

3817

g_signal_new ("alloc-named-color-reply",

3818

G_TYPE_FROM_CLASS (klass),

3819

G_SIGNAL_RUN_LAST,

3820

G_STRUCT_OFFSET (XigCodecClass, alloc_named_color_reply),

3821

NULL, NULL,

3822

g_cclosure_marshal_VOID__POINTER,

3823

G_TYPE_NONE, 1, G_TYPE_POINTER);

3824

signals[ALLOC_COLOR_CELLS] =

3825

g_signal_new ("alloc-color-cells",

3826

G_TYPE_FROM_CLASS (klass),

3827

G_SIGNAL_RUN_LAST,

3828

G_STRUCT_OFFSET (XigCodecClass, alloc_color_cells),

3829

NULL, NULL,

3830

g_cclosure_marshal_VOID__POINTER,

3831

G_TYPE_NONE, 1, G_TYPE_POINTER);

3832

signals[ALLOC_COLOR_CELLS_REPLY] =

3833

g_signal_new ("alloc-color-cells-reply",

3834

G_TYPE_FROM_CLASS (klass),

3835

G_SIGNAL_RUN_LAST,

3836

G_STRUCT_OFFSET (XigCodecClass, alloc_color_cells_reply),

3837

NULL, NULL,

3838

g_cclosure_marshal_VOID__POINTER,

3839

G_TYPE_NONE, 1, G_TYPE_POINTER);

3840

signals[ALLOC_COLOR_PLANES] =

3841

g_signal_new ("alloc-color-planes",

3842

G_TYPE_FROM_CLASS (klass),

3843

G_SIGNAL_RUN_LAST,

3844

G_STRUCT_OFFSET (XigCodecClass, alloc_color_planes),

3845

NULL, NULL,

3846

g_cclosure_marshal_VOID__POINTER,

3847

G_TYPE_NONE, 1, G_TYPE_POINTER);

3848

signals[ALLOC_COLOR_PLANES_REPLY] =

3849

g_signal_new ("alloc-color-planes-reply",

3850

G_TYPE_FROM_CLASS (klass),

3851

G_SIGNAL_RUN_LAST,

3852

G_STRUCT_OFFSET (XigCodecClass, alloc_color_planes_reply),

3853

NULL, NULL,

3854

g_cclosure_marshal_VOID__POINTER,

3855

G_TYPE_NONE, 1, G_TYPE_POINTER);

3856

signals[FREE_COLORS] =

3857

g_signal_new ("free-colors",

3858

G_TYPE_FROM_CLASS (klass),

3859

G_SIGNAL_RUN_LAST,

3860

G_STRUCT_OFFSET (XigCodecClass, free_colors),

3861

NULL, NULL,

3862

g_cclosure_marshal_VOID__POINTER,

3863

G_TYPE_NONE, 1, G_TYPE_POINTER);

3864

signals[STORE_COLORS] =

3865

g_signal_new ("store-colors",

3866

G_TYPE_FROM_CLASS (klass),

3867

G_SIGNAL_RUN_LAST,

3868

G_STRUCT_OFFSET (XigCodecClass, store_colors),

3869

NULL, NULL,

3870

g_cclosure_marshal_VOID__POINTER,

3871

G_TYPE_NONE, 1, G_TYPE_POINTER);

3872

signals[STORE_NAMED_COLOR] =

3873

g_signal_new ("store-named-color",

3874

G_TYPE_FROM_CLASS (klass),

3875

G_SIGNAL_RUN_LAST,

3876

G_STRUCT_OFFSET (XigCodecClass, store_named_color),

3877

NULL, NULL,

3878

g_cclosure_marshal_VOID__POINTER,

3879

G_TYPE_NONE, 1, G_TYPE_POINTER);

3880

signals[QUERY_COLORS] =

3881

g_signal_new ("query-colors",

3882

G_TYPE_FROM_CLASS (klass),

3883

G_SIGNAL_RUN_LAST,

3884

G_STRUCT_OFFSET (XigCodecClass, query_colors),

3885

NULL, NULL,

3886

g_cclosure_marshal_VOID__POINTER,

3887

G_TYPE_NONE, 1, G_TYPE_POINTER);

3888

signals[QUERY_COLORS_REPLY] =

3889

g_signal_new ("query-colors-reply",

3890

G_TYPE_FROM_CLASS (klass),

3891

G_SIGNAL_RUN_LAST,

3892

G_STRUCT_OFFSET (XigCodecClass, query_colors_reply),

3893

NULL, NULL,

3894

g_cclosure_marshal_VOID__POINTER,

3895

G_TYPE_NONE, 1, G_TYPE_POINTER);

3896

signals[LOOKUP_COLOR] =

3897

g_signal_new ("lookup-color",

3898

G_TYPE_FROM_CLASS (klass),

3899

G_SIGNAL_RUN_LAST,

3900

G_STRUCT_OFFSET (XigCodecClass, lookup_color),

3901

NULL, NULL,

3902

g_cclosure_marshal_VOID__POINTER,

3903

G_TYPE_NONE, 1, G_TYPE_POINTER);

3904

signals[LOOKUP_COLOR_REPLY] =

3905

g_signal_new ("lookup-color-reply",

3906

G_TYPE_FROM_CLASS (klass),

3907

G_SIGNAL_RUN_LAST,

3908

G_STRUCT_OFFSET (XigCodecClass, lookup_color_reply),

3909

NULL, NULL,

3910

g_cclosure_marshal_VOID__POINTER,

3911

G_TYPE_NONE, 1, G_TYPE_POINTER);

3912

signals[CREATE_CURSOR] =

3913

g_signal_new ("create-cursor",

3914

G_TYPE_FROM_CLASS (klass),

3915

G_SIGNAL_RUN_LAST,

3916

G_STRUCT_OFFSET (XigCodecClass, create_cursor),

3917

NULL, NULL,

3918

g_cclosure_marshal_VOID__POINTER,

3919

G_TYPE_NONE, 1, G_TYPE_POINTER);

3920

signals[CREATE_GLYPH_CURSOR] =

3921

g_signal_new ("create-glyph-cursor",

3922

G_TYPE_FROM_CLASS (klass),

3923

G_SIGNAL_RUN_LAST,

3924

G_STRUCT_OFFSET (XigCodecClass, create_glyph_cursor),

3925

NULL, NULL,

3926

g_cclosure_marshal_VOID__POINTER,

3927

G_TYPE_NONE, 1, G_TYPE_POINTER);

3928

signals[FREE_CURSOR] =

3929

g_signal_new ("free-cursor",

3930

G_TYPE_FROM_CLASS (klass),

3931

G_SIGNAL_RUN_LAST,

3932

G_STRUCT_OFFSET (XigCodecClass, free_cursor),

3933

NULL, NULL,

3934

g_cclosure_marshal_VOID__POINTER,

3935

G_TYPE_NONE, 1, G_TYPE_POINTER);

3936

signals[RECOLOR_CURSOR] =

3937

g_signal_new ("recolor-cursor",

3938

G_TYPE_FROM_CLASS (klass),

3939

G_SIGNAL_RUN_LAST,

3940

G_STRUCT_OFFSET (XigCodecClass, recolor_cursor),

3941

NULL, NULL,

3942

g_cclosure_marshal_VOID__POINTER,

3943

G_TYPE_NONE, 1, G_TYPE_POINTER);

3944

signals[QUERY_BEST_SIZE] =

3945

g_signal_new ("query-best-size",

3946

G_TYPE_FROM_CLASS (klass),

3947

G_SIGNAL_RUN_LAST,

3948

G_STRUCT_OFFSET (XigCodecClass, query_best_size),

3949

NULL, NULL,

3950

g_cclosure_marshal_VOID__POINTER,

3951

G_TYPE_NONE, 1, G_TYPE_POINTER);

3952

signals[QUERY_BEST_SIZE_REPLY] =

3953

g_signal_new ("query-best-size-reply",

3954

G_TYPE_FROM_CLASS (klass),

3955

G_SIGNAL_RUN_LAST,

3956

G_STRUCT_OFFSET (XigCodecClass, query_best_size_reply),

3957

NULL, NULL,

3958

g_cclosure_marshal_VOID__POINTER,

3959

G_TYPE_NONE, 1, G_TYPE_POINTER);

3960

signals[QUERY_EXTENSION] =

3961

g_signal_new ("query-extension",

3962

G_TYPE_FROM_CLASS (klass),

3963

G_SIGNAL_RUN_LAST,

3964

G_STRUCT_OFFSET (XigCodecClass, query_extension),

3965

NULL, NULL,

3966

g_cclosure_marshal_VOID__POINTER,

3967

G_TYPE_NONE, 1, G_TYPE_POINTER);

3968

signals[QUERY_EXTENSION_REPLY] =

3969

g_signal_new ("query-extension-reply",

3970

G_TYPE_FROM_CLASS (klass),

3971

G_SIGNAL_RUN_LAST,

3972

G_STRUCT_OFFSET (XigCodecClass, query_extension_reply),

3973

NULL, NULL,

3974

g_cclosure_marshal_VOID__POINTER,

3975

G_TYPE_NONE, 1, G_TYPE_POINTER);

3976

signals[LIST_EXTENSIONS] =

3977

g_signal_new ("list-extensions",

3978

G_TYPE_FROM_CLASS (klass),

3979

G_SIGNAL_RUN_LAST,

3980

G_STRUCT_OFFSET (XigCodecClass, list_extensions),

3981

NULL, NULL,

3982

g_cclosure_marshal_VOID__POINTER,

3983

G_TYPE_NONE, 1, G_TYPE_POINTER);

3984

signals[LIST_EXTENSIONS_REPLY] =

3985

g_signal_new ("list-extensions-reply",

3986

G_TYPE_FROM_CLASS (klass),

3987

G_SIGNAL_RUN_LAST,

3988

G_STRUCT_OFFSET (XigCodecClass, list_extensions_reply),

3989

NULL, NULL,

3990

g_cclosure_marshal_VOID__POINTER,

3991

G_TYPE_NONE, 1, G_TYPE_POINTER);

3992

signals[CHANGE_KEYBOARD_MAPPING] =

3993

g_signal_new ("change-keyboard-mapping",

3994

G_TYPE_FROM_CLASS (klass),

3995

G_SIGNAL_RUN_LAST,

3996

G_STRUCT_OFFSET (XigCodecClass, change_keyboard_mapping),

3997

NULL, NULL,

3998

g_cclosure_marshal_VOID__POINTER,

3999

G_TYPE_NONE, 1, G_TYPE_POINTER);

4000

signals[GET_KEYBOARD_MAPPING] =

4001

g_signal_new ("get-keyboard-mapping",

4002

G_TYPE_FROM_CLASS (klass),

4003

G_SIGNAL_RUN_LAST,

4004

G_STRUCT_OFFSET (XigCodecClass, get_keyboard_mapping),

4005

NULL, NULL,

4006

g_cclosure_marshal_VOID__POINTER,

4007

G_TYPE_NONE, 1, G_TYPE_POINTER);

4008

signals[GET_KEYBOARD_MAPPING_REPLY] =

4009

g_signal_new ("get-keyboard-mapping-reply",

4010

G_TYPE_FROM_CLASS (klass),

4011

G_SIGNAL_RUN_LAST,

4012

G_STRUCT_OFFSET (XigCodecClass, get_keyboard_mapping_reply),

4013

NULL, NULL,

4014

g_cclosure_marshal_VOID__POINTER,

4015

G_TYPE_NONE, 1, G_TYPE_POINTER);

4016

signals[CHANGE_KEYBOARD_CONTROL] =

4017

g_signal_new ("change-keyboard-control",

4018

G_TYPE_FROM_CLASS (klass),

4019

G_SIGNAL_RUN_LAST,

4020

G_STRUCT_OFFSET (XigCodecClass, change_keyboard_control),

4021

NULL, NULL,

4022

g_cclosure_marshal_VOID__POINTER,

4023

G_TYPE_NONE, 1, G_TYPE_POINTER);

4024

signals[GET_KEYBOARD_CONTROL] =

4025

g_signal_new ("get-keyboard-control",

4026

G_TYPE_FROM_CLASS (klass),

4027

G_SIGNAL_RUN_LAST,

4028

G_STRUCT_OFFSET (XigCodecClass, get_keyboard_control),

4029

NULL, NULL,

4030

g_cclosure_marshal_VOID__POINTER,

4031

G_TYPE_NONE, 1, G_TYPE_POINTER);

4032

signals[GET_KEYBOARD_CONTROL_REPLY] =

4033

g_signal_new ("get-keyboard-control-reply",

4034

G_TYPE_FROM_CLASS (klass),

4035

G_SIGNAL_RUN_LAST,

4036

G_STRUCT_OFFSET (XigCodecClass, get_keyboard_control_reply),

4037

NULL, NULL,

4038

g_cclosure_marshal_VOID__POINTER,

4039

G_TYPE_NONE, 1, G_TYPE_POINTER);

4040

signals[BELL] =

4041

g_signal_new ("bell",

4042

G_TYPE_FROM_CLASS (klass),

4043

G_SIGNAL_RUN_LAST,

4044

G_STRUCT_OFFSET (XigCodecClass, bell),

4045

NULL, NULL,

4046

g_cclosure_marshal_VOID__POINTER,

4047

G_TYPE_NONE, 1, G_TYPE_POINTER);

4048

signals[CHANGE_POINTER_CONTROL] =

4049

g_signal_new ("change-pointer-control",

4050

G_TYPE_FROM_CLASS (klass),

4051

G_SIGNAL_RUN_LAST,

4052

G_STRUCT_OFFSET (XigCodecClass, change_pointer_control),

4053

NULL, NULL,

4054

g_cclosure_marshal_VOID__POINTER,

4055

G_TYPE_NONE, 1, G_TYPE_POINTER);

4056

signals[GET_POINTER_CONTROL] =

4057

g_signal_new ("get-pointer-control",

4058

G_TYPE_FROM_CLASS (klass),

4059

G_SIGNAL_RUN_LAST,

4060

G_STRUCT_OFFSET (XigCodecClass, get_pointer_control),

4061

NULL, NULL,

4062

g_cclosure_marshal_VOID__POINTER,

4063

G_TYPE_NONE, 1, G_TYPE_POINTER);

4064

signals[GET_POINTER_CONTROL_REPLY] =

4065

g_signal_new ("get-pointer-control-reply",

4066

G_TYPE_FROM_CLASS (klass),

4067

G_SIGNAL_RUN_LAST,

4068

G_STRUCT_OFFSET (XigCodecClass, get_pointer_control_reply),

4069

NULL, NULL,

4070

g_cclosure_marshal_VOID__POINTER,

4071

G_TYPE_NONE, 1, G_TYPE_POINTER);

4072

signals[SET_SCREEN_SAVER] =

4073

g_signal_new ("set-screen-saver",

4074

G_TYPE_FROM_CLASS (klass),

4075

G_SIGNAL_RUN_LAST,

4076

G_STRUCT_OFFSET (XigCodecClass, set_screen_saver),

4077

NULL, NULL,

4078

g_cclosure_marshal_VOID__POINTER,

4079

G_TYPE_NONE, 1, G_TYPE_POINTER);

4080

signals[GET_SCREEN_SAVER] =

4081

g_signal_new ("get-screen-saver",

4082

G_TYPE_FROM_CLASS (klass),

4083

G_SIGNAL_RUN_LAST,

4084

G_STRUCT_OFFSET (XigCodecClass, get_screen_saver),

4085

NULL, NULL,

4086

g_cclosure_marshal_VOID__POINTER,

4087

G_TYPE_NONE, 1, G_TYPE_POINTER);

4088

signals[GET_SCREEN_SAVER_REPLY] =

4089

g_signal_new ("get-screen-saver-reply",

4090

G_TYPE_FROM_CLASS (klass),

4091

G_SIGNAL_RUN_LAST,

4092

G_STRUCT_OFFSET (XigCodecClass, get_screen_saver_reply),

4093

NULL, NULL,

4094

g_cclosure_marshal_VOID__POINTER,

4095

G_TYPE_NONE, 1, G_TYPE_POINTER);

4096

signals[CHANGE_HOSTS] =

4097

g_signal_new ("change-hosts",

4098

G_TYPE_FROM_CLASS (klass),

4099

G_SIGNAL_RUN_LAST,

4100

G_STRUCT_OFFSET (XigCodecClass, change_hosts),

4101

NULL, NULL,

4102

g_cclosure_marshal_VOID__POINTER,

4103

G_TYPE_NONE, 1, G_TYPE_POINTER);

4104

signals[LIST_HOSTS] =

4105

g_signal_new ("list-hosts",

4106

G_TYPE_FROM_CLASS (klass),

4107

G_SIGNAL_RUN_LAST,

4108

G_STRUCT_OFFSET (XigCodecClass, list_hosts),

4109

NULL, NULL,

4110

g_cclosure_marshal_VOID__POINTER,

4111

G_TYPE_NONE, 1, G_TYPE_POINTER);

4112

signals[LIST_HOSTS_REPLY] =

4113

g_signal_new ("list-hosts-reply",

4114

G_TYPE_FROM_CLASS (klass),

4115

G_SIGNAL_RUN_LAST,

4116

G_STRUCT_OFFSET (XigCodecClass, list_hosts_reply),

4117

NULL, NULL,

4118

g_cclosure_marshal_VOID__POINTER,

4119

G_TYPE_NONE, 1, G_TYPE_POINTER);

4120

signals[SET_ACCESS_CONTROL] =

4121

g_signal_new ("set-access-control",

4122

G_TYPE_FROM_CLASS (klass),

4123

G_SIGNAL_RUN_LAST,

4124

G_STRUCT_OFFSET (XigCodecClass, set_access_control),

4125

NULL, NULL,

4126

g_cclosure_marshal_VOID__POINTER,

4127

G_TYPE_NONE, 1, G_TYPE_POINTER);

4128

signals[SET_CLOSE_DOWN_MODE] =

4129

g_signal_new ("set-close-down-mode",

4130

G_TYPE_FROM_CLASS (klass),

4131

G_SIGNAL_RUN_LAST,

4132

G_STRUCT_OFFSET (XigCodecClass, set_close_down_mode),

4133

NULL, NULL,

4134

g_cclosure_marshal_VOID__POINTER,

4135

G_TYPE_NONE, 1, G_TYPE_POINTER);

4136

signals[KILL_CLIENT] =

4137

g_signal_new ("kill-client",

4138

G_TYPE_FROM_CLASS (klass),

4139

G_SIGNAL_RUN_LAST,

4140

G_STRUCT_OFFSET (XigCodecClass, kill_client),

4141

NULL, NULL,

4142

g_cclosure_marshal_VOID__POINTER,

4143

G_TYPE_NONE, 1, G_TYPE_POINTER);

4144

signals[ROTATE_PROPERTIES] =

4145

g_signal_new ("rotate-properties",

4146

G_TYPE_FROM_CLASS (klass),

4147

G_SIGNAL_RUN_LAST,

4148

G_STRUCT_OFFSET (XigCodecClass, rotate_properties),

4149

NULL, NULL,

4150

g_cclosure_marshal_VOID__POINTER,

4151

G_TYPE_NONE, 1, G_TYPE_POINTER);

4152

signals[FORCE_SCREEN_SAVER] =

4153

g_signal_new ("force-screen-saver",

4154

G_TYPE_FROM_CLASS (klass),

4155

G_SIGNAL_RUN_LAST,

4156

G_STRUCT_OFFSET (XigCodecClass, force_screen_saver),

4157

NULL, NULL,

4158

g_cclosure_marshal_VOID__POINTER,

4159

G_TYPE_NONE, 1, G_TYPE_POINTER);

4160

signals[SET_POINTER_MAPPING] =

4161

g_signal_new ("set-pointer-mapping",

4162

G_TYPE_FROM_CLASS (klass),

4163

G_SIGNAL_RUN_LAST,

4164

G_STRUCT_OFFSET (XigCodecClass, set_pointer_mapping),

4165

NULL, NULL,

4166

g_cclosure_marshal_VOID__POINTER,

4167

G_TYPE_NONE, 1, G_TYPE_POINTER);

4168

signals[SET_POINTER_MAPPING_REPLY] =

4169

g_signal_new ("set-pointer-mapping-reply",

4170

G_TYPE_FROM_CLASS (klass),

4171

G_SIGNAL_RUN_LAST,

4172

G_STRUCT_OFFSET (XigCodecClass, set_pointer_mapping_reply),

4173

NULL, NULL,

4174

g_cclosure_marshal_VOID__POINTER,

4175

G_TYPE_NONE, 1, G_TYPE_POINTER);

4176

signals[GET_POINTER_MAPPING] =

4177

g_signal_new ("get-pointer-mapping",

4178

G_TYPE_FROM_CLASS (klass),

4179

G_SIGNAL_RUN_LAST,

4180

G_STRUCT_OFFSET (XigCodecClass, get_pointer_mapping),

4181

NULL, NULL,

4182

g_cclosure_marshal_VOID__POINTER,

4183

G_TYPE_NONE, 1, G_TYPE_POINTER);

4184

signals[GET_POINTER_MAPPING_REPLY] =

4185

g_signal_new ("get-pointer-mapping-reply",

4186

G_TYPE_FROM_CLASS (klass),

4187

G_SIGNAL_RUN_LAST,

4188

G_STRUCT_OFFSET (XigCodecClass, get_pointer_mapping_reply),

4189

NULL, NULL,

4190

g_cclosure_marshal_VOID__POINTER,

4191

G_TYPE_NONE, 1, G_TYPE_POINTER);

4192

signals[SET_MODIFIER_MAPPING] =

4193

g_signal_new ("set-modifier-mapping",

4194

G_TYPE_FROM_CLASS (klass),

4195

G_SIGNAL_RUN_LAST,

4196

G_STRUCT_OFFSET (XigCodecClass, set_modifier_mapping),

4197

NULL, NULL,

4198

g_cclosure_marshal_VOID__POINTER,

4199

G_TYPE_NONE, 1, G_TYPE_POINTER);

4200

signals[SET_MODIFIER_MAPPING_REPLY] =

4201

g_signal_new ("set-modifier-mapping-reply",

4202

G_TYPE_FROM_CLASS (klass),

4203

G_SIGNAL_RUN_LAST,

4204

G_STRUCT_OFFSET (XigCodecClass, set_modifier_mapping_reply),

4205

NULL, NULL,

4206

g_cclosure_marshal_VOID__POINTER,

4207

G_TYPE_NONE, 1, G_TYPE_POINTER);

4208

signals[GET_MODIFIER_MAPPING] =

4209

g_signal_new ("get-modifier-mapping",

4210

G_TYPE_FROM_CLASS (klass),

4211

G_SIGNAL_RUN_LAST,

4212

G_STRUCT_OFFSET (XigCodecClass, get_modifier_mapping),

4213

NULL, NULL,

4214

g_cclosure_marshal_VOID__POINTER,

4215

G_TYPE_NONE, 1, G_TYPE_POINTER);

4216

signals[GET_MODIFIER_MAPPING_REPLY] =

4217

g_signal_new ("get-modifier-mapping-reply",

4218

G_TYPE_FROM_CLASS (klass),

4219

G_SIGNAL_RUN_LAST,

4220

G_STRUCT_OFFSET (XigCodecClass, get_modifier_mapping_reply),

4221

NULL, NULL,

4222

g_cclosure_marshal_VOID__POINTER,

4223

G_TYPE_NONE, 1, G_TYPE_POINTER);

4224

signals[NO_OPERATION] =

4225

g_signal_new ("no-operation",

4226

G_TYPE_FROM_CLASS (klass),

4227

G_SIGNAL_RUN_LAST,

4228

G_STRUCT_OFFSET (XigCodecClass, no_operation),

4229

NULL, NULL,

4230

g_cclosure_marshal_VOID__POINTER,

4231

G_TYPE_NONE, 1, G_TYPE_POINTER);

4232

signals[BIGREQ_ENABLE] =

4233

g_signal_new ("BIGREQ-enable",

4234

G_TYPE_FROM_CLASS (klass),

4235

G_SIGNAL_RUN_LAST,

4236

G_STRUCT_OFFSET (XigCodecClass, BIGREQ_enable),

4237

NULL, NULL,

4238

g_cclosure_marshal_VOID__POINTER,

4239

G_TYPE_NONE, 1, G_TYPE_POINTER);

4240

signals[BIGREQ_ENABLE_REPLY] =

4241

g_signal_new ("BIGREQ-enable-reply",

4242

G_TYPE_FROM_CLASS (klass),

4243

G_SIGNAL_RUN_LAST,

4244

G_STRUCT_OFFSET (XigCodecClass, BIGREQ_enable_reply),

4245

NULL, NULL,

4246

g_cclosure_marshal_VOID__POINTER,

4247

G_TYPE_NONE, 1, G_TYPE_POINTER);

4248

signals[SYNC_COUNTER_NOTIFY] =

4249

g_signal_new ("SYNC-counter-notify",

4250

G_TYPE_FROM_CLASS (klass),

4251

G_SIGNAL_RUN_LAST,

4252

G_STRUCT_OFFSET (XigCodecClass, SYNC_counter_notify),

4253

NULL, NULL,

4254

g_cclosure_marshal_VOID__POINTER,

4255

G_TYPE_NONE, 1, G_TYPE_POINTER);

4256

signals[SYNC_ALARM_NOTIFY] =

4257

g_signal_new ("SYNC-alarm-notify",

4258

G_TYPE_FROM_CLASS (klass),

4259

G_SIGNAL_RUN_LAST,

4260

G_STRUCT_OFFSET (XigCodecClass, SYNC_alarm_notify),

4261

NULL, NULL,

4262

g_cclosure_marshal_VOID__POINTER,

4263

G_TYPE_NONE, 1, G_TYPE_POINTER);

4264

signals[SYNC_INITIALIZE] =

4265

g_signal_new ("SYNC-initialize",

4266

G_TYPE_FROM_CLASS (klass),

4267

G_SIGNAL_RUN_LAST,

4268

G_STRUCT_OFFSET (XigCodecClass, SYNC_initialize),

4269

NULL, NULL,

4270

g_cclosure_marshal_VOID__POINTER,

4271

G_TYPE_NONE, 1, G_TYPE_POINTER);

4272

signals[SYNC_INITIALIZE_REPLY] =

4273

g_signal_new ("SYNC-initialize-reply",

4274

G_TYPE_FROM_CLASS (klass),

4275

G_SIGNAL_RUN_LAST,

4276

G_STRUCT_OFFSET (XigCodecClass, SYNC_initialize_reply),

4277

NULL, NULL,

4278

g_cclosure_marshal_VOID__POINTER,

4279

G_TYPE_NONE, 1, G_TYPE_POINTER);

4280

signals[SYNC_LIST_SYSTEM_COUNTERS] =

4281

g_signal_new ("SYNC-list-system-counters",

4282

G_TYPE_FROM_CLASS (klass),

4283

G_SIGNAL_RUN_LAST,

4284

G_STRUCT_OFFSET (XigCodecClass, SYNC_list_system_counters),

4285

NULL, NULL,

4286

g_cclosure_marshal_VOID__POINTER,

4287

G_TYPE_NONE, 1, G_TYPE_POINTER);

4288

signals[SYNC_LIST_SYSTEM_COUNTERS_REPLY] =

4289

g_signal_new ("SYNC-list-system-counters-reply",

4290

G_TYPE_FROM_CLASS (klass),

4291

G_SIGNAL_RUN_LAST,

4292

G_STRUCT_OFFSET (XigCodecClass, SYNC_list_system_counters_reply),

4293

NULL, NULL,

4294

g_cclosure_marshal_VOID__POINTER,

4295

G_TYPE_NONE, 1, G_TYPE_POINTER);

4296

signals[SYNC_CREATE_COUNTER] =

4297

g_signal_new ("SYNC-create-counter",

4298

G_TYPE_FROM_CLASS (klass),

4299

G_SIGNAL_RUN_LAST,

4300

G_STRUCT_OFFSET (XigCodecClass, SYNC_create_counter),

4301

NULL, NULL,

4302

g_cclosure_marshal_VOID__POINTER,

4303

G_TYPE_NONE, 1, G_TYPE_POINTER);

4304

signals[SYNC_DESTROY_COUNTER] =

4305

g_signal_new ("SYNC-destroy-counter",

4306

G_TYPE_FROM_CLASS (klass),

4307

G_SIGNAL_RUN_LAST,

4308

G_STRUCT_OFFSET (XigCodecClass, SYNC_destroy_counter),

4309

NULL, NULL,

4310

g_cclosure_marshal_VOID__POINTER,

4311

G_TYPE_NONE, 1, G_TYPE_POINTER);

4312

signals[SYNC_QUERY_COUNTER] =

4313

g_signal_new ("SYNC-query-counter",

4314

G_TYPE_FROM_CLASS (klass),

4315

G_SIGNAL_RUN_LAST,

4316

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_counter),

4317

NULL, NULL,

4318

g_cclosure_marshal_VOID__POINTER,

4319

G_TYPE_NONE, 1, G_TYPE_POINTER);

4320

signals[SYNC_QUERY_COUNTER_REPLY] =

4321

g_signal_new ("SYNC-query-counter-reply",

4322

G_TYPE_FROM_CLASS (klass),

4323

G_SIGNAL_RUN_LAST,

4324

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_counter_reply),

4325

NULL, NULL,

4326

g_cclosure_marshal_VOID__POINTER,

4327

G_TYPE_NONE, 1, G_TYPE_POINTER);

4328

signals[SYNC_AWAIT] =

4329

g_signal_new ("SYNC-await",

4330

G_TYPE_FROM_CLASS (klass),

4331

G_SIGNAL_RUN_LAST,

4332

G_STRUCT_OFFSET (XigCodecClass, SYNC_await),

4333

NULL, NULL,

4334

g_cclosure_marshal_VOID__POINTER,

4335

G_TYPE_NONE, 1, G_TYPE_POINTER);

4336

signals[SYNC_CHANGE_COUNTER] =

4337

g_signal_new ("SYNC-change-counter",

4338

G_TYPE_FROM_CLASS (klass),

4339

G_SIGNAL_RUN_LAST,

4340

G_STRUCT_OFFSET (XigCodecClass, SYNC_change_counter),

4341

NULL, NULL,

4342

g_cclosure_marshal_VOID__POINTER,

4343

G_TYPE_NONE, 1, G_TYPE_POINTER);

4344

signals[SYNC_SET_COUNTER] =

4345

g_signal_new ("SYNC-set-counter",

4346

G_TYPE_FROM_CLASS (klass),

4347

G_SIGNAL_RUN_LAST,

4348

G_STRUCT_OFFSET (XigCodecClass, SYNC_set_counter),

4349

NULL, NULL,

4350

g_cclosure_marshal_VOID__POINTER,

4351

G_TYPE_NONE, 1, G_TYPE_POINTER);

4352

signals[SYNC_CREATE_ALARM] =

4353

g_signal_new ("SYNC-create-alarm",

4354

G_TYPE_FROM_CLASS (klass),

4355

G_SIGNAL_RUN_LAST,

4356

G_STRUCT_OFFSET (XigCodecClass, SYNC_create_alarm),

4357

NULL, NULL,

4358

g_cclosure_marshal_VOID__POINTER,

4359

G_TYPE_NONE, 1, G_TYPE_POINTER);

4360

signals[SYNC_CHANGE_ALARM] =

4361

g_signal_new ("SYNC-change-alarm",

4362

G_TYPE_FROM_CLASS (klass),

4363

G_SIGNAL_RUN_LAST,

4364

G_STRUCT_OFFSET (XigCodecClass, SYNC_change_alarm),

4365

NULL, NULL,

4366

g_cclosure_marshal_VOID__POINTER,

4367

G_TYPE_NONE, 1, G_TYPE_POINTER);

4368

signals[SYNC_DESTROY_ALARM] =

4369

g_signal_new ("SYNC-destroy-alarm",

4370

G_TYPE_FROM_CLASS (klass),

4371

G_SIGNAL_RUN_LAST,

4372

G_STRUCT_OFFSET (XigCodecClass, SYNC_destroy_alarm),

4373

NULL, NULL,

4374

g_cclosure_marshal_VOID__POINTER,

4375

G_TYPE_NONE, 1, G_TYPE_POINTER);

4376

signals[SYNC_QUERY_ALARM] =

4377

g_signal_new ("SYNC-query-alarm",

4378

G_TYPE_FROM_CLASS (klass),

4379

G_SIGNAL_RUN_LAST,

4380

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_alarm),

4381

NULL, NULL,

4382

g_cclosure_marshal_VOID__POINTER,

4383

G_TYPE_NONE, 1, G_TYPE_POINTER);

4384

signals[SYNC_QUERY_ALARM_REPLY] =

4385

g_signal_new ("SYNC-query-alarm-reply",

4386

G_TYPE_FROM_CLASS (klass),

4387

G_SIGNAL_RUN_LAST,

4388

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_alarm_reply),

4389

NULL, NULL,

4390

g_cclosure_marshal_VOID__POINTER,

4391

G_TYPE_NONE, 1, G_TYPE_POINTER);

4392

signals[SYNC_SET_PRIORITY] =

4393

g_signal_new ("SYNC-set-priority",

4394

G_TYPE_FROM_CLASS (klass),

4395

G_SIGNAL_RUN_LAST,

4396

G_STRUCT_OFFSET (XigCodecClass, SYNC_set_priority),

4397

NULL, NULL,

4398

g_cclosure_marshal_VOID__POINTER,

4399

G_TYPE_NONE, 1, G_TYPE_POINTER);

4400

signals[SYNC_GET_PRIORITY] =

4401

g_signal_new ("SYNC-get-priority",

4402

G_TYPE_FROM_CLASS (klass),

4403

G_SIGNAL_RUN_LAST,

4404

G_STRUCT_OFFSET (XigCodecClass, SYNC_get_priority),

4405

NULL, NULL,

4406

g_cclosure_marshal_VOID__POINTER,

4407

G_TYPE_NONE, 1, G_TYPE_POINTER);

4408

signals[SYNC_GET_PRIORITY_REPLY] =

4409

g_signal_new ("SYNC-get-priority-reply",

4410

G_TYPE_FROM_CLASS (klass),

4411

G_SIGNAL_RUN_LAST,

4412

G_STRUCT_OFFSET (XigCodecClass, SYNC_get_priority_reply),

4413

NULL, NULL,

4414

g_cclosure_marshal_VOID__POINTER,

4415

G_TYPE_NONE, 1, G_TYPE_POINTER);

4416

signals[SYNC_CREATE_FENCE] =

4417

g_signal_new ("SYNC-create-fence",

4418

G_TYPE_FROM_CLASS (klass),

4419

G_SIGNAL_RUN_LAST,

4420

G_STRUCT_OFFSET (XigCodecClass, SYNC_create_fence),

4421

NULL, NULL,

4422

g_cclosure_marshal_VOID__POINTER,

4423

G_TYPE_NONE, 1, G_TYPE_POINTER);

4424

signals[SYNC_TRIGGER_FENCE] =

4425

g_signal_new ("SYNC-trigger-fence",

4426

G_TYPE_FROM_CLASS (klass),

4427

G_SIGNAL_RUN_LAST,

4428

G_STRUCT_OFFSET (XigCodecClass, SYNC_trigger_fence),

4429

NULL, NULL,

4430

g_cclosure_marshal_VOID__POINTER,

4431

G_TYPE_NONE, 1, G_TYPE_POINTER);

4432

signals[SYNC_RESET_FENCE] =

4433

g_signal_new ("SYNC-reset-fence",

4434

G_TYPE_FROM_CLASS (klass),

4435

G_SIGNAL_RUN_LAST,

4436

G_STRUCT_OFFSET (XigCodecClass, SYNC_reset_fence),

4437

NULL, NULL,

4438

g_cclosure_marshal_VOID__POINTER,

4439

G_TYPE_NONE, 1, G_TYPE_POINTER);

4440

signals[SYNC_DESTROY_FENCE] =

4441

g_signal_new ("SYNC-destroy-fence",

4442

G_TYPE_FROM_CLASS (klass),

4443

G_SIGNAL_RUN_LAST,

4444

G_STRUCT_OFFSET (XigCodecClass, SYNC_destroy_fence),

4445

NULL, NULL,

4446

g_cclosure_marshal_VOID__POINTER,

4447

G_TYPE_NONE, 1, G_TYPE_POINTER);

4448

signals[SYNC_QUERY_FENCE] =

4449

g_signal_new ("SYNC-query-fence",

4450

G_TYPE_FROM_CLASS (klass),

4451

G_SIGNAL_RUN_LAST,

4452

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_fence),

4453

NULL, NULL,

4454

g_cclosure_marshal_VOID__POINTER,

4455

G_TYPE_NONE, 1, G_TYPE_POINTER);

4456

signals[SYNC_QUERY_FENCE_REPLY] =

4457

g_signal_new ("SYNC-query-fence-reply",

4458

G_TYPE_FROM_CLASS (klass),

4459

G_SIGNAL_RUN_LAST,

4460

G_STRUCT_OFFSET (XigCodecClass, SYNC_query_fence_reply),

4461

NULL, NULL,

4462

g_cclosure_marshal_VOID__POINTER,

4463

G_TYPE_NONE, 1, G_TYPE_POINTER);

4464

signals[SYNC_AWAIT_FENCE] =

4465

g_signal_new ("SYNC-await-fence",

4466

G_TYPE_FROM_CLASS (klass),

4467

G_SIGNAL_RUN_LAST,

4468

G_STRUCT_OFFSET (XigCodecClass, SYNC_await_fence),

4469

NULL, NULL,

4470

g_cclosure_marshal_VOID__POINTER,

4471

G_TYPE_NONE, 1, G_TYPE_POINTER);

4472

signals[RANDR_SCREEN_CHANGE_NOTIFY] =

4473

g_signal_new ("RANDR-screen-change-notify",

4474

G_TYPE_FROM_CLASS (klass),

4475

G_SIGNAL_RUN_LAST,

4476

G_STRUCT_OFFSET (XigCodecClass, RANDR_screen_change_notify),

4477

NULL, NULL,

4478

g_cclosure_marshal_VOID__POINTER,

4479

G_TYPE_NONE, 1, G_TYPE_POINTER);

4480

signals[RANDR_NOTIFY] =

4481

g_signal_new ("RANDR-notify",

4482

G_TYPE_FROM_CLASS (klass),

4483

G_SIGNAL_RUN_LAST,

4484

G_STRUCT_OFFSET (XigCodecClass, RANDR_notify),

4485

NULL, NULL,

4486

g_cclosure_marshal_VOID__POINTER,

4487

G_TYPE_NONE, 1, G_TYPE_POINTER);

4488

signals[RANDR_QUERY_VERSION] =

4489

g_signal_new ("RANDR-query-version",

4490

G_TYPE_FROM_CLASS (klass),

4491

G_SIGNAL_RUN_LAST,

4492

G_STRUCT_OFFSET (XigCodecClass, RANDR_query_version),

4493

NULL, NULL,

4494

g_cclosure_marshal_VOID__POINTER,

4495

G_TYPE_NONE, 1, G_TYPE_POINTER);

4496

signals[RANDR_QUERY_VERSION_REPLY] =

4497

g_signal_new ("RANDR-query-version-reply",

4498

G_TYPE_FROM_CLASS (klass),

4499

G_SIGNAL_RUN_LAST,

4500

G_STRUCT_OFFSET (XigCodecClass, RANDR_query_version_reply),

4501

NULL, NULL,

4502

g_cclosure_marshal_VOID__POINTER,

4503

G_TYPE_NONE, 1, G_TYPE_POINTER);

4504

signals[RANDR_SET_SCREEN_CONFIG] =

4505

g_signal_new ("RANDR-set-screen-config",

4506

G_TYPE_FROM_CLASS (klass),

4507

G_SIGNAL_RUN_LAST,

4508

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_screen_config),

4509

NULL, NULL,

4510

g_cclosure_marshal_VOID__POINTER,

4511

G_TYPE_NONE, 1, G_TYPE_POINTER);

4512

signals[RANDR_SET_SCREEN_CONFIG_REPLY] =

4513

g_signal_new ("RANDR-set-screen-config-reply",

4514

G_TYPE_FROM_CLASS (klass),

4515

G_SIGNAL_RUN_LAST,

4516

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_screen_config_reply),

4517

NULL, NULL,

4518

g_cclosure_marshal_VOID__POINTER,

4519

G_TYPE_NONE, 1, G_TYPE_POINTER);

4520

signals[RANDR_SELECT_INPUT] =

4521

g_signal_new ("RANDR-select-input",

4522

G_TYPE_FROM_CLASS (klass),

4523

G_SIGNAL_RUN_LAST,

4524

G_STRUCT_OFFSET (XigCodecClass, RANDR_select_input),

4525

NULL, NULL,

4526

g_cclosure_marshal_VOID__POINTER,

4527

G_TYPE_NONE, 1, G_TYPE_POINTER);

4528

signals[RANDR_GET_SCREEN_INFO] =

4529

g_signal_new ("RANDR-get-screen-info",

4530

G_TYPE_FROM_CLASS (klass),

4531

G_SIGNAL_RUN_LAST,

4532

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_info),

4533

NULL, NULL,

4534

g_cclosure_marshal_VOID__POINTER,

4535

G_TYPE_NONE, 1, G_TYPE_POINTER);

4536

signals[RANDR_GET_SCREEN_INFO_REPLY] =

4537

g_signal_new ("RANDR-get-screen-info-reply",

4538

G_TYPE_FROM_CLASS (klass),

4539

G_SIGNAL_RUN_LAST,

4540

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_info_reply),

4541

NULL, NULL,

4542

g_cclosure_marshal_VOID__POINTER,

4543

G_TYPE_NONE, 1, G_TYPE_POINTER);

4544

signals[RANDR_GET_SCREEN_SIZE_RANGE] =

4545

g_signal_new ("RANDR-get-screen-size-range",

4546

G_TYPE_FROM_CLASS (klass),

4547

G_SIGNAL_RUN_LAST,

4548

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_size_range),

4549

NULL, NULL,

4550

g_cclosure_marshal_VOID__POINTER,

4551

G_TYPE_NONE, 1, G_TYPE_POINTER);

4552

signals[RANDR_GET_SCREEN_SIZE_RANGE_REPLY] =

4553

g_signal_new ("RANDR-get-screen-size-range-reply",

4554

G_TYPE_FROM_CLASS (klass),

4555

G_SIGNAL_RUN_LAST,

4556

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_size_range_reply),

4557

NULL, NULL,

4558

g_cclosure_marshal_VOID__POINTER,

4559

G_TYPE_NONE, 1, G_TYPE_POINTER);

4560

signals[RANDR_SET_SCREEN_SIZE] =

4561

g_signal_new ("RANDR-set-screen-size",

4562

G_TYPE_FROM_CLASS (klass),

4563

G_SIGNAL_RUN_LAST,

4564

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_screen_size),

4565

NULL, NULL,

4566

g_cclosure_marshal_VOID__POINTER,

4567

G_TYPE_NONE, 1, G_TYPE_POINTER);

4568

signals[RANDR_GET_SCREEN_RESOURCES] =

4569

g_signal_new ("RANDR-get-screen-resources",

4570

G_TYPE_FROM_CLASS (klass),

4571

G_SIGNAL_RUN_LAST,

4572

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_resources),

4573

NULL, NULL,

4574

g_cclosure_marshal_VOID__POINTER,

4575

G_TYPE_NONE, 1, G_TYPE_POINTER);

4576

signals[RANDR_GET_SCREEN_RESOURCES_REPLY] =

4577

g_signal_new ("RANDR-get-screen-resources-reply",

4578

G_TYPE_FROM_CLASS (klass),

4579

G_SIGNAL_RUN_LAST,

4580

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_resources_reply),

4581

NULL, NULL,

4582

g_cclosure_marshal_VOID__POINTER,

4583

G_TYPE_NONE, 1, G_TYPE_POINTER);

4584

signals[RANDR_GET_OUTPUT_INFO] =

4585

g_signal_new ("RANDR-get-output-info",

4586

G_TYPE_FROM_CLASS (klass),

4587

G_SIGNAL_RUN_LAST,

4588

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_info),

4589

NULL, NULL,

4590

g_cclosure_marshal_VOID__POINTER,

4591

G_TYPE_NONE, 1, G_TYPE_POINTER);

4592

signals[RANDR_GET_OUTPUT_INFO_REPLY] =

4593

g_signal_new ("RANDR-get-output-info-reply",

4594

G_TYPE_FROM_CLASS (klass),

4595

G_SIGNAL_RUN_LAST,

4596

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_info_reply),

4597

NULL, NULL,

4598

g_cclosure_marshal_VOID__POINTER,

4599

G_TYPE_NONE, 1, G_TYPE_POINTER);

4600

signals[RANDR_LIST_OUTPUT_PROPERTIES] =

4601

g_signal_new ("RANDR-list-output-properties",

4602

G_TYPE_FROM_CLASS (klass),

4603

G_SIGNAL_RUN_LAST,

4604

G_STRUCT_OFFSET (XigCodecClass, RANDR_list_output_properties),

4605

NULL, NULL,

4606

g_cclosure_marshal_VOID__POINTER,

4607

G_TYPE_NONE, 1, G_TYPE_POINTER);

4608

signals[RANDR_LIST_OUTPUT_PROPERTIES_REPLY] =

4609

g_signal_new ("RANDR-list-output-properties-reply",

4610

G_TYPE_FROM_CLASS (klass),

4611

G_SIGNAL_RUN_LAST,

4612

G_STRUCT_OFFSET (XigCodecClass, RANDR_list_output_properties_reply),

4613

NULL, NULL,

4614

g_cclosure_marshal_VOID__POINTER,

4615

G_TYPE_NONE, 1, G_TYPE_POINTER);

4616

signals[RANDR_QUERY_OUTPUT_PROPERTY] =

4617

g_signal_new ("RANDR-query-output-property",

4618

G_TYPE_FROM_CLASS (klass),

4619

G_SIGNAL_RUN_LAST,

4620

G_STRUCT_OFFSET (XigCodecClass, RANDR_query_output_property),

4621

NULL, NULL,

4622

g_cclosure_marshal_VOID__POINTER,

4623

G_TYPE_NONE, 1, G_TYPE_POINTER);

4624

signals[RANDR_QUERY_OUTPUT_PROPERTY_REPLY] =

4625

g_signal_new ("RANDR-query-output-property-reply",

4626

G_TYPE_FROM_CLASS (klass),

4627

G_SIGNAL_RUN_LAST,

4628

G_STRUCT_OFFSET (XigCodecClass, RANDR_query_output_property_reply),

4629

NULL, NULL,

4630

g_cclosure_marshal_VOID__POINTER,

4631

G_TYPE_NONE, 1, G_TYPE_POINTER);

4632

signals[RANDR_CONFIGURE_OUTPUT_PROPERTY] =

4633

g_signal_new ("RANDR-configure-output-property",

4634

G_TYPE_FROM_CLASS (klass),

4635

G_SIGNAL_RUN_LAST,

4636

G_STRUCT_OFFSET (XigCodecClass, RANDR_configure_output_property),

4637

NULL, NULL,

4638

g_cclosure_marshal_VOID__POINTER,

4639

G_TYPE_NONE, 1, G_TYPE_POINTER);

4640

signals[RANDR_CHANGE_OUTPUT_PROPERTY] =

4641

g_signal_new ("RANDR-change-output-property",

4642

G_TYPE_FROM_CLASS (klass),

4643

G_SIGNAL_RUN_LAST,

4644

G_STRUCT_OFFSET (XigCodecClass, RANDR_change_output_property),

4645

NULL, NULL,

4646

g_cclosure_marshal_VOID__POINTER,

4647

G_TYPE_NONE, 1, G_TYPE_POINTER);

4648

signals[RANDR_DELETE_OUTPUT_PROPERTY] =

4649

g_signal_new ("RANDR-delete-output-property",

4650

G_TYPE_FROM_CLASS (klass),

4651

G_SIGNAL_RUN_LAST,

4652

G_STRUCT_OFFSET (XigCodecClass, RANDR_delete_output_property),

4653

NULL, NULL,

4654

g_cclosure_marshal_VOID__POINTER,

4655

G_TYPE_NONE, 1, G_TYPE_POINTER);

4656

signals[RANDR_GET_OUTPUT_PROPERTY] =

4657

g_signal_new ("RANDR-get-output-property",

4658

G_TYPE_FROM_CLASS (klass),

4659

G_SIGNAL_RUN_LAST,

4660

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_property),

4661

NULL, NULL,

4662

g_cclosure_marshal_VOID__POINTER,

4663

G_TYPE_NONE, 1, G_TYPE_POINTER);

4664

signals[RANDR_GET_OUTPUT_PROPERTY_REPLY] =

4665

g_signal_new ("RANDR-get-output-property-reply",

4666

G_TYPE_FROM_CLASS (klass),

4667

G_SIGNAL_RUN_LAST,

4668

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_property_reply),

4669

NULL, NULL,

4670

g_cclosure_marshal_VOID__POINTER,

4671

G_TYPE_NONE, 1, G_TYPE_POINTER);

4672

signals[RANDR_CREATE_MODE] =

4673

g_signal_new ("RANDR-create-mode",

4674

G_TYPE_FROM_CLASS (klass),

4675

G_SIGNAL_RUN_LAST,

4676

G_STRUCT_OFFSET (XigCodecClass, RANDR_create_mode),

4677

NULL, NULL,

4678

g_cclosure_marshal_VOID__POINTER,

4679

G_TYPE_NONE, 1, G_TYPE_POINTER);

4680

signals[RANDR_CREATE_MODE_REPLY] =

4681

g_signal_new ("RANDR-create-mode-reply",

4682

G_TYPE_FROM_CLASS (klass),

4683

G_SIGNAL_RUN_LAST,

4684

G_STRUCT_OFFSET (XigCodecClass, RANDR_create_mode_reply),

4685

NULL, NULL,

4686

g_cclosure_marshal_VOID__POINTER,

4687

G_TYPE_NONE, 1, G_TYPE_POINTER);

4688

signals[RANDR_DESTROY_MODE] =

4689

g_signal_new ("RANDR-destroy-mode",

4690

G_TYPE_FROM_CLASS (klass),

4691

G_SIGNAL_RUN_LAST,

4692

G_STRUCT_OFFSET (XigCodecClass, RANDR_destroy_mode),

4693

NULL, NULL,

4694

g_cclosure_marshal_VOID__POINTER,

4695

G_TYPE_NONE, 1, G_TYPE_POINTER);

4696

signals[RANDR_ADD_OUTPUT_MODE] =

4697

g_signal_new ("RANDR-add-output-mode",

4698

G_TYPE_FROM_CLASS (klass),

4699

G_SIGNAL_RUN_LAST,

4700

G_STRUCT_OFFSET (XigCodecClass, RANDR_add_output_mode),

4701

NULL, NULL,

4702

g_cclosure_marshal_VOID__POINTER,

4703

G_TYPE_NONE, 1, G_TYPE_POINTER);

4704

signals[RANDR_DELETE_OUTPUT_MODE] =

4705

g_signal_new ("RANDR-delete-output-mode",

4706

G_TYPE_FROM_CLASS (klass),

4707

G_SIGNAL_RUN_LAST,

4708

G_STRUCT_OFFSET (XigCodecClass, RANDR_delete_output_mode),

4709

NULL, NULL,

4710

g_cclosure_marshal_VOID__POINTER,

4711

G_TYPE_NONE, 1, G_TYPE_POINTER);

4712

signals[RANDR_GET_CRTC_INFO] =

4713

g_signal_new ("RANDR-get-crtc-info",

4714

G_TYPE_FROM_CLASS (klass),

4715

G_SIGNAL_RUN_LAST,

4716

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_info),

4717

NULL, NULL,

4718

g_cclosure_marshal_VOID__POINTER,

4719

G_TYPE_NONE, 1, G_TYPE_POINTER);

4720

signals[RANDR_GET_CRTC_INFO_REPLY] =

4721

g_signal_new ("RANDR-get-crtc-info-reply",

4722

G_TYPE_FROM_CLASS (klass),

4723

G_SIGNAL_RUN_LAST,

4724

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_info_reply),

4725

NULL, NULL,

4726

g_cclosure_marshal_VOID__POINTER,

4727

G_TYPE_NONE, 1, G_TYPE_POINTER);

4728

signals[RANDR_SET_CRTC_CONFIG] =

4729

g_signal_new ("RANDR-set-crtc-config",

4730

G_TYPE_FROM_CLASS (klass),

4731

G_SIGNAL_RUN_LAST,

4732

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_crtc_config),

4733

NULL, NULL,

4734

g_cclosure_marshal_VOID__POINTER,

4735

G_TYPE_NONE, 1, G_TYPE_POINTER);

4736

signals[RANDR_SET_CRTC_CONFIG_REPLY] =

4737

g_signal_new ("RANDR-set-crtc-config-reply",

4738

G_TYPE_FROM_CLASS (klass),

4739

G_SIGNAL_RUN_LAST,

4740

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_crtc_config_reply),

4741

NULL, NULL,

4742

g_cclosure_marshal_VOID__POINTER,

4743

G_TYPE_NONE, 1, G_TYPE_POINTER);

4744

signals[RANDR_GET_CRTC_GAMMA_SIZE] =

4745

g_signal_new ("RANDR-get-crtc-gamma-size",

4746

G_TYPE_FROM_CLASS (klass),

4747

G_SIGNAL_RUN_LAST,

4748

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_gamma_size),

4749

NULL, NULL,

4750

g_cclosure_marshal_VOID__POINTER,

4751

G_TYPE_NONE, 1, G_TYPE_POINTER);

4752

signals[RANDR_GET_CRTC_GAMMA_SIZE_REPLY] =

4753

g_signal_new ("RANDR-get-crtc-gamma-size-reply",

4754

G_TYPE_FROM_CLASS (klass),

4755

G_SIGNAL_RUN_LAST,

4756

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_gamma_size_reply),

4757

NULL, NULL,

4758

g_cclosure_marshal_VOID__POINTER,

4759

G_TYPE_NONE, 1, G_TYPE_POINTER);

4760

signals[RANDR_GET_CRTC_GAMMA] =

4761

g_signal_new ("RANDR-get-crtc-gamma",

4762

G_TYPE_FROM_CLASS (klass),

4763

G_SIGNAL_RUN_LAST,

4764

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_gamma),

4765

NULL, NULL,

4766

g_cclosure_marshal_VOID__POINTER,

4767

G_TYPE_NONE, 1, G_TYPE_POINTER);

4768

signals[RANDR_GET_CRTC_GAMMA_REPLY] =

4769

g_signal_new ("RANDR-get-crtc-gamma-reply",

4770

G_TYPE_FROM_CLASS (klass),

4771

G_SIGNAL_RUN_LAST,

4772

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_gamma_reply),

4773

NULL, NULL,

4774

g_cclosure_marshal_VOID__POINTER,

4775

G_TYPE_NONE, 1, G_TYPE_POINTER);

4776

signals[RANDR_SET_CRTC_GAMMA] =

4777

g_signal_new ("RANDR-set-crtc-gamma",

4778

G_TYPE_FROM_CLASS (klass),

4779

G_SIGNAL_RUN_LAST,

4780

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_crtc_gamma),

4781

NULL, NULL,

4782

g_cclosure_marshal_VOID__POINTER,

4783

G_TYPE_NONE, 1, G_TYPE_POINTER);

4784

signals[RANDR_GET_SCREEN_RESOURCES_CURRENT] =

4785

g_signal_new ("RANDR-get-screen-resources-current",

4786

G_TYPE_FROM_CLASS (klass),

4787

G_SIGNAL_RUN_LAST,

4788

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_resources_current),

4789

NULL, NULL,

4790

g_cclosure_marshal_VOID__POINTER,

4791

G_TYPE_NONE, 1, G_TYPE_POINTER);

4792

signals[RANDR_GET_SCREEN_RESOURCES_CURRENT_REPLY] =

4793

g_signal_new ("RANDR-get-screen-resources-current-reply",

4794

G_TYPE_FROM_CLASS (klass),

4795

G_SIGNAL_RUN_LAST,

4796

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_screen_resources_current_reply),

4797

NULL, NULL,

4798

g_cclosure_marshal_VOID__POINTER,

4799

G_TYPE_NONE, 1, G_TYPE_POINTER);

4800

signals[RANDR_SET_CRTC_TRANSFORM] =

4801

g_signal_new ("RANDR-set-crtc-transform",

4802

G_TYPE_FROM_CLASS (klass),

4803

G_SIGNAL_RUN_LAST,

4804

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_crtc_transform),

4805

NULL, NULL,

4806

g_cclosure_marshal_VOID__POINTER,

4807

G_TYPE_NONE, 1, G_TYPE_POINTER);

4808

signals[RANDR_GET_CRTC_TRANSFORM] =

4809

g_signal_new ("RANDR-get-crtc-transform",

4810

G_TYPE_FROM_CLASS (klass),

4811

G_SIGNAL_RUN_LAST,

4812

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_transform),

4813

NULL, NULL,

4814

g_cclosure_marshal_VOID__POINTER,

4815

G_TYPE_NONE, 1, G_TYPE_POINTER);

4816

signals[RANDR_GET_CRTC_TRANSFORM_REPLY] =

4817

g_signal_new ("RANDR-get-crtc-transform-reply",

4818

G_TYPE_FROM_CLASS (klass),

4819

G_SIGNAL_RUN_LAST,

4820

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_crtc_transform_reply),

4821

NULL, NULL,

4822

g_cclosure_marshal_VOID__POINTER,

4823

G_TYPE_NONE, 1, G_TYPE_POINTER);

4824

signals[RANDR_GET_PANNING] =

4825

g_signal_new ("RANDR-get-panning",

4826

G_TYPE_FROM_CLASS (klass),

4827

G_SIGNAL_RUN_LAST,

4828

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_panning),

4829

NULL, NULL,

4830

g_cclosure_marshal_VOID__POINTER,

4831

G_TYPE_NONE, 1, G_TYPE_POINTER);

4832

signals[RANDR_GET_PANNING_REPLY] =

4833

g_signal_new ("RANDR-get-panning-reply",

4834

G_TYPE_FROM_CLASS (klass),

4835

G_SIGNAL_RUN_LAST,

4836

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_panning_reply),

4837

NULL, NULL,

4838

g_cclosure_marshal_VOID__POINTER,

4839

G_TYPE_NONE, 1, G_TYPE_POINTER);

4840

signals[RANDR_SET_PANNING] =

4841

g_signal_new ("RANDR-set-panning",

4842

G_TYPE_FROM_CLASS (klass),

4843

G_SIGNAL_RUN_LAST,

4844

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_panning),

4845

NULL, NULL,

4846

g_cclosure_marshal_VOID__POINTER,

4847

G_TYPE_NONE, 1, G_TYPE_POINTER);

4848

signals[RANDR_SET_PANNING_REPLY] =

4849

g_signal_new ("RANDR-set-panning-reply",

4850

G_TYPE_FROM_CLASS (klass),

4851

G_SIGNAL_RUN_LAST,

4852

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_panning_reply),

4853

NULL, NULL,

4854

g_cclosure_marshal_VOID__POINTER,

4855

G_TYPE_NONE, 1, G_TYPE_POINTER);

4856

signals[RANDR_SET_OUTPUT_PRIMARY] =

4857

g_signal_new ("RANDR-set-output-primary",

4858

G_TYPE_FROM_CLASS (klass),

4859

G_SIGNAL_RUN_LAST,

4860

G_STRUCT_OFFSET (XigCodecClass, RANDR_set_output_primary),

4861

NULL, NULL,

4862

g_cclosure_marshal_VOID__POINTER,

4863

G_TYPE_NONE, 1, G_TYPE_POINTER);

4864

signals[RANDR_GET_OUTPUT_PRIMARY] =

4865

g_signal_new ("RANDR-get-output-primary",

4866

G_TYPE_FROM_CLASS (klass),

4867

G_SIGNAL_RUN_LAST,

4868

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_primary),

4869

NULL, NULL,

4870

g_cclosure_marshal_VOID__POINTER,

4871

G_TYPE_NONE, 1, G_TYPE_POINTER);

4872

signals[RANDR_GET_OUTPUT_PRIMARY_REPLY] =

4873

g_signal_new ("RANDR-get-output-primary-reply",

4874

G_TYPE_FROM_CLASS (klass),

4875

G_SIGNAL_RUN_LAST,

4876

G_STRUCT_OFFSET (XigCodecClass, RANDR_get_output_primary_reply),

4877

NULL, NULL,

4878

g_cclosure_marshal_VOID__POINTER,

4879

G_TYPE_NONE, 1, G_TYPE_POINTER);

4880

signals[XINERAMA_QUERY_VERSION] =

4881

g_signal_new ("XINERAMA-query-version",

4882

G_TYPE_FROM_CLASS (klass),

4883

G_SIGNAL_RUN_LAST,

4884

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_query_version),

4885

NULL, NULL,

4886

g_cclosure_marshal_VOID__POINTER,

4887

G_TYPE_NONE, 1, G_TYPE_POINTER);

4888

signals[XINERAMA_QUERY_VERSION_REPLY] =

4889

g_signal_new ("XINERAMA-query-version-reply",

4890

G_TYPE_FROM_CLASS (klass),

4891

G_SIGNAL_RUN_LAST,

4892

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_query_version_reply),

4893

NULL, NULL,

4894

g_cclosure_marshal_VOID__POINTER,

4895

G_TYPE_NONE, 1, G_TYPE_POINTER);

4896

signals[XINERAMA_GET_STATE] =

4897

g_signal_new ("XINERAMA-get-state",

4898

G_TYPE_FROM_CLASS (klass),

4899

G_SIGNAL_RUN_LAST,

4900

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_state),

4901

NULL, NULL,

4902

g_cclosure_marshal_VOID__POINTER,

4903

G_TYPE_NONE, 1, G_TYPE_POINTER);

4904

signals[XINERAMA_GET_STATE_REPLY] =

4905

g_signal_new ("XINERAMA-get-state-reply",

4906

G_TYPE_FROM_CLASS (klass),

4907

G_SIGNAL_RUN_LAST,

4908

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_state_reply),

4909

NULL, NULL,

4910

g_cclosure_marshal_VOID__POINTER,

4911

G_TYPE_NONE, 1, G_TYPE_POINTER);

4912

signals[XINERAMA_GET_SCREEN_COUNT] =

4913

g_signal_new ("XINERAMA-get-screen-count",

4914

G_TYPE_FROM_CLASS (klass),

4915

G_SIGNAL_RUN_LAST,

4916

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_screen_count),

4917

NULL, NULL,

4918

g_cclosure_marshal_VOID__POINTER,

4919

G_TYPE_NONE, 1, G_TYPE_POINTER);

4920

signals[XINERAMA_GET_SCREEN_COUNT_REPLY] =

4921

g_signal_new ("XINERAMA-get-screen-count-reply",

4922

G_TYPE_FROM_CLASS (klass),

4923

G_SIGNAL_RUN_LAST,

4924

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_screen_count_reply),

4925

NULL, NULL,

4926

g_cclosure_marshal_VOID__POINTER,

4927

G_TYPE_NONE, 1, G_TYPE_POINTER);

4928

signals[XINERAMA_GET_SCREEN_SIZE] =

4929

g_signal_new ("XINERAMA-get-screen-size",

4930

G_TYPE_FROM_CLASS (klass),

4931

G_SIGNAL_RUN_LAST,

4932

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_screen_size),

4933

NULL, NULL,

4934

g_cclosure_marshal_VOID__POINTER,

4935

G_TYPE_NONE, 1, G_TYPE_POINTER);

4936

signals[XINERAMA_GET_SCREEN_SIZE_REPLY] =

4937

g_signal_new ("XINERAMA-get-screen-size-reply",

4938

G_TYPE_FROM_CLASS (klass),

4939

G_SIGNAL_RUN_LAST,

4940

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_get_screen_size_reply),

4941

NULL, NULL,

4942

g_cclosure_marshal_VOID__POINTER,

4943

G_TYPE_NONE, 1, G_TYPE_POINTER);

4944

signals[XINERAMA_IS_ACTIVE] =

4945

g_signal_new ("XINERAMA-is-active",

4946

G_TYPE_FROM_CLASS (klass),

4947

G_SIGNAL_RUN_LAST,

4948

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_is_active),

4949

NULL, NULL,

4950

g_cclosure_marshal_VOID__POINTER,

4951

G_TYPE_NONE, 1, G_TYPE_POINTER);

4952

signals[XINERAMA_IS_ACTIVE_REPLY] =

4953

g_signal_new ("XINERAMA-is-active-reply",

4954

G_TYPE_FROM_CLASS (klass),

4955

G_SIGNAL_RUN_LAST,

4956

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_is_active_reply),

4957

NULL, NULL,

4958

g_cclosure_marshal_VOID__POINTER,

4959

G_TYPE_NONE, 1, G_TYPE_POINTER);

4960

signals[XINERAMA_QUERY_SCREENS] =

4961

g_signal_new ("XINERAMA-query-screens",

4962

G_TYPE_FROM_CLASS (klass),

4963

G_SIGNAL_RUN_LAST,

4964

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_query_screens),

4965

NULL, NULL,

4966

g_cclosure_marshal_VOID__POINTER,

4967

G_TYPE_NONE, 1, G_TYPE_POINTER);

4968

signals[XINERAMA_QUERY_SCREENS_REPLY] =

4969

g_signal_new ("XINERAMA-query-screens-reply",

4970

G_TYPE_FROM_CLASS (klass),

4971

G_SIGNAL_RUN_LAST,

4972

G_STRUCT_OFFSET (XigCodecClass, XINERAMA_query_screens_reply),

4973

NULL, NULL,

4974

g_cclosure_marshal_VOID__POINTER,

4975

G_TYPE_NONE, 1, G_TYPE_POINTER);

4976

signals[XKB_NEW_KEYBOARD_NOTIFY] =

4977

g_signal_new ("XKB-new-keyboard-notify",

4978

G_TYPE_FROM_CLASS (klass),

4979

G_SIGNAL_RUN_LAST,

4980

G_STRUCT_OFFSET (XigCodecClass, XKB_new_keyboard_notify),

4981

NULL, NULL,

4982

g_cclosure_marshal_VOID__POINTER,

4983

G_TYPE_NONE, 1, G_TYPE_POINTER);

4984

signals[XKB_MAP_NOTIFY] =

4985

g_signal_new ("XKB-map-notify",

4986

G_TYPE_FROM_CLASS (klass),

4987

G_SIGNAL_RUN_LAST,

4988

G_STRUCT_OFFSET (XigCodecClass, XKB_map_notify),

4989

NULL, NULL,

4990

g_cclosure_marshal_VOID__POINTER,

4991

G_TYPE_NONE, 1, G_TYPE_POINTER);

4992

signals[XKB_STATE_NOTIFY] =

4993

g_signal_new ("XKB-state-notify",

4994

G_TYPE_FROM_CLASS (klass),

4995

G_SIGNAL_RUN_LAST,

4996

G_STRUCT_OFFSET (XigCodecClass, XKB_state_notify),

4997

NULL, NULL,

4998

g_cclosure_marshal_VOID__POINTER,

4999

G_TYPE_NONE, 1, G_TYPE_POINTER);

5000

signals[XKB_CONTROLS_NOTIFY] =

5001

g_signal_new ("XKB-controls-notify",

5002

G_TYPE_FROM_CLASS (klass),

5003

G_SIGNAL_RUN_LAST,

5004

G_STRUCT_OFFSET (XigCodecClass, XKB_controls_notify),

5005

NULL, NULL,

5006

g_cclosure_marshal_VOID__POINTER,

5007

G_TYPE_NONE, 1, G_TYPE_POINTER);

5008

signals[XKB_INDICATOR_STATE_NOTIFY] =

5009

g_signal_new ("XKB-indicator-state-notify",

5010

G_TYPE_FROM_CLASS (klass),

5011

G_SIGNAL_RUN_LAST,

5012

G_STRUCT_OFFSET (XigCodecClass, XKB_indicator_state_notify),

5013

NULL, NULL,

5014

g_cclosure_marshal_VOID__POINTER,

5015

G_TYPE_NONE, 1, G_TYPE_POINTER);

5016

signals[XKB_INDICATOR_MAP_NOTIFY] =

5017

g_signal_new ("XKB-indicator-map-notify",

5018

G_TYPE_FROM_CLASS (klass),

5019

G_SIGNAL_RUN_LAST,

5020

G_STRUCT_OFFSET (XigCodecClass, XKB_indicator_map_notify),

5021

NULL, NULL,

5022

g_cclosure_marshal_VOID__POINTER,

5023

G_TYPE_NONE, 1, G_TYPE_POINTER);

5024

signals[XKB_NAMES_NOTIFY] =

5025

g_signal_new ("XKB-names-notify",

5026

G_TYPE_FROM_CLASS (klass),

5027

G_SIGNAL_RUN_LAST,

5028

G_STRUCT_OFFSET (XigCodecClass, XKB_names_notify),

5029

NULL, NULL,

5030

g_cclosure_marshal_VOID__POINTER,

5031

G_TYPE_NONE, 1, G_TYPE_POINTER);

5032

signals[XKB_COMPAT_MAP_NOTIFY] =

5033

g_signal_new ("XKB-compat-map-notify",

5034

G_TYPE_FROM_CLASS (klass),

5035

G_SIGNAL_RUN_LAST,

5036

G_STRUCT_OFFSET (XigCodecClass, XKB_compat_map_notify),

5037

NULL, NULL,

5038

g_cclosure_marshal_VOID__POINTER,

5039

G_TYPE_NONE, 1, G_TYPE_POINTER);

5040

signals[XKB_BELL_NOTIFY] =

5041

g_signal_new ("XKB-bell-notify",

5042

G_TYPE_FROM_CLASS (klass),

5043

G_SIGNAL_RUN_LAST,

5044

G_STRUCT_OFFSET (XigCodecClass, XKB_bell_notify),

5045

NULL, NULL,

5046

g_cclosure_marshal_VOID__POINTER,

5047

G_TYPE_NONE, 1, G_TYPE_POINTER);

5048

signals[XKB_ACTION_MESSAGE] =

5049

g_signal_new ("XKB-action-message",

5050

G_TYPE_FROM_CLASS (klass),

5051

G_SIGNAL_RUN_LAST,

5052

G_STRUCT_OFFSET (XigCodecClass, XKB_action_message),

5053

NULL, NULL,

5054

g_cclosure_marshal_VOID__POINTER,

5055

G_TYPE_NONE, 1, G_TYPE_POINTER);

5056

signals[XKB_ACCESS_XNOTIFY] =

5057

g_signal_new ("XKB-access-xnotify",

5058

G_TYPE_FROM_CLASS (klass),

5059

G_SIGNAL_RUN_LAST,

5060

G_STRUCT_OFFSET (XigCodecClass, XKB_access_xnotify),

5061

NULL, NULL,

5062

g_cclosure_marshal_VOID__POINTER,

5063

G_TYPE_NONE, 1, G_TYPE_POINTER);

5064

signals[XKB_EXTENSION_DEVICE_NOTIFY] =

5065

g_signal_new ("XKB-extension-device-notify",

5066

G_TYPE_FROM_CLASS (klass),

5067

G_SIGNAL_RUN_LAST,

5068

G_STRUCT_OFFSET (XigCodecClass, XKB_extension_device_notify),

5069

NULL, NULL,

5070

g_cclosure_marshal_VOID__POINTER,

5071

G_TYPE_NONE, 1, G_TYPE_POINTER);

5072

signals[XKB_USE_EXTENSION] =

5073

g_signal_new ("XKB-use-extension",

5074

G_TYPE_FROM_CLASS (klass),

5075

G_SIGNAL_RUN_LAST,

5076

G_STRUCT_OFFSET (XigCodecClass, XKB_use_extension),

5077

NULL, NULL,

5078

g_cclosure_marshal_VOID__POINTER,

5079

G_TYPE_NONE, 1, G_TYPE_POINTER);

5080

signals[XKB_USE_EXTENSION_REPLY] =

5081

g_signal_new ("XKB-use-extension-reply",

5082

G_TYPE_FROM_CLASS (klass),

5083

G_SIGNAL_RUN_LAST,

5084

G_STRUCT_OFFSET (XigCodecClass, XKB_use_extension_reply),

5085

NULL, NULL,

5086

g_cclosure_marshal_VOID__POINTER,

5087

G_TYPE_NONE, 1, G_TYPE_POINTER);

5088

signals[XKB_SELECT_EVENTS] =

5089

g_signal_new ("XKB-select-events",

5090

G_TYPE_FROM_CLASS (klass),

5091

G_SIGNAL_RUN_LAST,

5092

G_STRUCT_OFFSET (XigCodecClass, XKB_select_events),

5093

NULL, NULL,

5094

g_cclosure_marshal_VOID__POINTER,

5095

G_TYPE_NONE, 1, G_TYPE_POINTER);

5096

signals[XKB_BELL] =

5097

g_signal_new ("XKB-bell",

5098

G_TYPE_FROM_CLASS (klass),

5099

G_SIGNAL_RUN_LAST,

5100

G_STRUCT_OFFSET (XigCodecClass, XKB_bell),

5101

NULL, NULL,

5102

g_cclosure_marshal_VOID__POINTER,

5103

G_TYPE_NONE, 1, G_TYPE_POINTER);

5104

signals[XKB_GET_STATE] =

5105

g_signal_new ("XKB-get-state",

5106

G_TYPE_FROM_CLASS (klass),

5107

G_SIGNAL_RUN_LAST,

5108

G_STRUCT_OFFSET (XigCodecClass, XKB_get_state),

5109

NULL, NULL,

5110

g_cclosure_marshal_VOID__POINTER,

5111

G_TYPE_NONE, 1, G_TYPE_POINTER);

5112

signals[XKB_GET_STATE_REPLY] =

5113

g_signal_new ("XKB-get-state-reply",

5114

G_TYPE_FROM_CLASS (klass),

5115

G_SIGNAL_RUN_LAST,

5116

G_STRUCT_OFFSET (XigCodecClass, XKB_get_state_reply),

5117

NULL, NULL,

5118

g_cclosure_marshal_VOID__POINTER,

5119

G_TYPE_NONE, 1, G_TYPE_POINTER);

5120

signals[XKB_LATCH_LOCK_STATE] =

5121

g_signal_new ("XKB-latch-lock-state",

5122

G_TYPE_FROM_CLASS (klass),

5123

G_SIGNAL_RUN_LAST,

5124

G_STRUCT_OFFSET (XigCodecClass, XKB_latch_lock_state),

5125

NULL, NULL,

5126

g_cclosure_marshal_VOID__POINTER,

5127

G_TYPE_NONE, 1, G_TYPE_POINTER);

5128

signals[XKB_GET_CONTROLS] =

5129

g_signal_new ("XKB-get-controls",

5130

G_TYPE_FROM_CLASS (klass),

5131

G_SIGNAL_RUN_LAST,

5132

G_STRUCT_OFFSET (XigCodecClass, XKB_get_controls),

5133

NULL, NULL,

5134

g_cclosure_marshal_VOID__POINTER,

5135

G_TYPE_NONE, 1, G_TYPE_POINTER);

5136

signals[XKB_GET_CONTROLS_REPLY] =

5137

g_signal_new ("XKB-get-controls-reply",

5138

G_TYPE_FROM_CLASS (klass),

5139

G_SIGNAL_RUN_LAST,

5140

G_STRUCT_OFFSET (XigCodecClass, XKB_get_controls_reply),

5141

NULL, NULL,

5142

g_cclosure_marshal_VOID__POINTER,

5143

G_TYPE_NONE, 1, G_TYPE_POINTER);

5144

signals[XKB_SET_CONTROLS] =

5145

g_signal_new ("XKB-set-controls",

5146

G_TYPE_FROM_CLASS (klass),

5147

G_SIGNAL_RUN_LAST,

5148

G_STRUCT_OFFSET (XigCodecClass, XKB_set_controls),

5149

NULL, NULL,

5150

g_cclosure_marshal_VOID__POINTER,

5151

G_TYPE_NONE, 1, G_TYPE_POINTER);

5152

signals[XKB_GET_MAP] =

5153

g_signal_new ("XKB-get-map",

5154

G_TYPE_FROM_CLASS (klass),

5155

G_SIGNAL_RUN_LAST,

5156

G_STRUCT_OFFSET (XigCodecClass, XKB_get_map),

5157

NULL, NULL,

5158

g_cclosure_marshal_VOID__POINTER,

5159

G_TYPE_NONE, 1, G_TYPE_POINTER);

5160

signals[XKB_GET_MAP_REPLY] =

5161

g_signal_new ("XKB-get-map-reply",

5162

G_TYPE_FROM_CLASS (klass),

5163

G_SIGNAL_RUN_LAST,

5164

G_STRUCT_OFFSET (XigCodecClass, XKB_get_map_reply),

5165

NULL, NULL,

5166

g_cclosure_marshal_VOID__POINTER,

5167

G_TYPE_NONE, 1, G_TYPE_POINTER);

5168

signals[XKB_SET_MAP] =

5169

g_signal_new ("XKB-set-map",

5170

G_TYPE_FROM_CLASS (klass),

5171

G_SIGNAL_RUN_LAST,

5172

G_STRUCT_OFFSET (XigCodecClass, XKB_set_map),

5173

NULL, NULL,

5174

g_cclosure_marshal_VOID__POINTER,

5175

G_TYPE_NONE, 1, G_TYPE_POINTER);

5176

signals[XKB_GET_COMPAT_MAP] =

5177

g_signal_new ("XKB-get-compat-map",

5178

G_TYPE_FROM_CLASS (klass),

5179

G_SIGNAL_RUN_LAST,

5180

G_STRUCT_OFFSET (XigCodecClass, XKB_get_compat_map),

5181

NULL, NULL,

5182

g_cclosure_marshal_VOID__POINTER,

5183

G_TYPE_NONE, 1, G_TYPE_POINTER);

5184

signals[XKB_GET_COMPAT_MAP_REPLY] =

5185

g_signal_new ("XKB-get-compat-map-reply",

5186

G_TYPE_FROM_CLASS (klass),

5187

G_SIGNAL_RUN_LAST,

5188

G_STRUCT_OFFSET (XigCodecClass, XKB_get_compat_map_reply),

5189

NULL, NULL,

5190

g_cclosure_marshal_VOID__POINTER,

5191

G_TYPE_NONE, 1, G_TYPE_POINTER);

5192

signals[XKB_SET_COMPAT_MAP] =

5193

g_signal_new ("XKB-set-compat-map",

5194

G_TYPE_FROM_CLASS (klass),

5195

G_SIGNAL_RUN_LAST,

5196

G_STRUCT_OFFSET (XigCodecClass, XKB_set_compat_map),

5197

NULL, NULL,

5198

g_cclosure_marshal_VOID__POINTER,

5199

G_TYPE_NONE, 1, G_TYPE_POINTER);

5200

signals[XKB_GET_INDICATOR_STATE] =

5201

g_signal_new ("XKB-get-indicator-state",

5202

G_TYPE_FROM_CLASS (klass),

5203

G_SIGNAL_RUN_LAST,

5204

G_STRUCT_OFFSET (XigCodecClass, XKB_get_indicator_state),

5205

NULL, NULL,

5206

g_cclosure_marshal_VOID__POINTER,

5207

G_TYPE_NONE, 1, G_TYPE_POINTER);

5208

signals[XKB_GET_INDICATOR_STATE_REPLY] =

5209

g_signal_new ("XKB-get-indicator-state-reply",

5210

G_TYPE_FROM_CLASS (klass),

5211

G_SIGNAL_RUN_LAST,

5212

G_STRUCT_OFFSET (XigCodecClass, XKB_get_indicator_state_reply),

5213

NULL, NULL,

5214

g_cclosure_marshal_VOID__POINTER,

5215

G_TYPE_NONE, 1, G_TYPE_POINTER);

5216

signals[XKB_GET_INDICATOR_MAP] =

5217

g_signal_new ("XKB-get-indicator-map",

5218

G_TYPE_FROM_CLASS (klass),

5219

G_SIGNAL_RUN_LAST,

5220

G_STRUCT_OFFSET (XigCodecClass, XKB_get_indicator_map),

5221

NULL, NULL,

5222

g_cclosure_marshal_VOID__POINTER,

5223

G_TYPE_NONE, 1, G_TYPE_POINTER);

5224

signals[XKB_GET_INDICATOR_MAP_REPLY] =

5225

g_signal_new ("XKB-get-indicator-map-reply",

5226

G_TYPE_FROM_CLASS (klass),

5227

G_SIGNAL_RUN_LAST,

5228

G_STRUCT_OFFSET (XigCodecClass, XKB_get_indicator_map_reply),

5229

NULL, NULL,

5230

g_cclosure_marshal_VOID__POINTER,

5231

G_TYPE_NONE, 1, G_TYPE_POINTER);

5232

signals[XKB_SET_INDICATOR_MAP] =

5233

g_signal_new ("XKB-set-indicator-map",

5234

G_TYPE_FROM_CLASS (klass),

5235

G_SIGNAL_RUN_LAST,

5236

G_STRUCT_OFFSET (XigCodecClass, XKB_set_indicator_map),

5237

NULL, NULL,

5238

g_cclosure_marshal_VOID__POINTER,

5239

G_TYPE_NONE, 1, G_TYPE_POINTER);

5240

signals[XKB_GET_NAMED_INDICATOR] =

5241

g_signal_new ("XKB-get-named-indicator",

5242

G_TYPE_FROM_CLASS (klass),

5243

G_SIGNAL_RUN_LAST,

5244

G_STRUCT_OFFSET (XigCodecClass, XKB_get_named_indicator),

5245

NULL, NULL,

5246

g_cclosure_marshal_VOID__POINTER,

5247

G_TYPE_NONE, 1, G_TYPE_POINTER);

5248

signals[XKB_GET_NAMED_INDICATOR_REPLY] =

5249

g_signal_new ("XKB-get-named-indicator-reply",

5250

G_TYPE_FROM_CLASS (klass),

5251

G_SIGNAL_RUN_LAST,

5252

G_STRUCT_OFFSET (XigCodecClass, XKB_get_named_indicator_reply),

5253

NULL, NULL,

5254

g_cclosure_marshal_VOID__POINTER,

5255

G_TYPE_NONE, 1, G_TYPE_POINTER);

5256

signals[XKB_SET_NAMED_INDICATOR] =

5257

g_signal_new ("XKB-set-named-indicator",

5258

G_TYPE_FROM_CLASS (klass),

5259

G_SIGNAL_RUN_LAST,

5260

G_STRUCT_OFFSET (XigCodecClass, XKB_set_named_indicator),

5261

NULL, NULL,

5262

g_cclosure_marshal_VOID__POINTER,

5263

G_TYPE_NONE, 1, G_TYPE_POINTER);

5264

signals[XKB_GET_NAMES] =

5265

g_signal_new ("XKB-get-names",

5266

G_TYPE_FROM_CLASS (klass),

5267

G_SIGNAL_RUN_LAST,

5268

G_STRUCT_OFFSET (XigCodecClass, XKB_get_names),

5269

NULL, NULL,

5270

g_cclosure_marshal_VOID__POINTER,

5271

G_TYPE_NONE, 1, G_TYPE_POINTER);

5272

signals[XKB_GET_NAMES_REPLY] =

5273

g_signal_new ("XKB-get-names-reply",

5274

G_TYPE_FROM_CLASS (klass),

5275

G_SIGNAL_RUN_LAST,

5276

G_STRUCT_OFFSET (XigCodecClass, XKB_get_names_reply),

5277

NULL, NULL,

5278

g_cclosure_marshal_VOID__POINTER,

5279

G_TYPE_NONE, 1, G_TYPE_POINTER);

5280

signals[XKB_SET_NAMES] =

5281

g_signal_new ("XKB-set-names",

5282

G_TYPE_FROM_CLASS (klass),

5283

G_SIGNAL_RUN_LAST,

5284

G_STRUCT_OFFSET (XigCodecClass, XKB_set_names),

5285

NULL, NULL,

5286

g_cclosure_marshal_VOID__POINTER,

5287

G_TYPE_NONE, 1, G_TYPE_POINTER);

5288

signals[XKB_GET_GEOMETRY] =

5289

g_signal_new ("XKB-get-geometry",

5290

G_TYPE_FROM_CLASS (klass),

5291

G_SIGNAL_RUN_LAST,

5292

G_STRUCT_OFFSET (XigCodecClass, XKB_get_geometry),

5293

NULL, NULL,

5294

g_cclosure_marshal_VOID__POINTER,

5295

G_TYPE_NONE, 1, G_TYPE_POINTER);

5296

signals[XKB_GET_GEOMETRY_REPLY] =

5297

g_signal_new ("XKB-get-geometry-reply",

5298

G_TYPE_FROM_CLASS (klass),

5299

G_SIGNAL_RUN_LAST,

5300

G_STRUCT_OFFSET (XigCodecClass, XKB_get_geometry_reply),

5301

NULL, NULL,

5302

g_cclosure_marshal_VOID__POINTER,

5303

G_TYPE_NONE, 1, G_TYPE_POINTER);

5304

signals[XKB_SET_GEOMETRY] =

5305

g_signal_new ("XKB-set-geometry",

5306

G_TYPE_FROM_CLASS (klass),

5307

G_SIGNAL_RUN_LAST,

5308

G_STRUCT_OFFSET (XigCodecClass, XKB_set_geometry),

5309

NULL, NULL,

5310

g_cclosure_marshal_VOID__POINTER,

5311

G_TYPE_NONE, 1, G_TYPE_POINTER);

5312

signals[XKB_PER_CLIENT_FLAGS] =

5313

g_signal_new ("XKB-per-client-flags",

5314

G_TYPE_FROM_CLASS (klass),

5315

G_SIGNAL_RUN_LAST,

5316

G_STRUCT_OFFSET (XigCodecClass, XKB_per_client_flags),

5317

NULL, NULL,

5318

g_cclosure_marshal_VOID__POINTER,

5319

G_TYPE_NONE, 1, G_TYPE_POINTER);

5320

signals[XKB_PER_CLIENT_FLAGS_REPLY] =

5321

g_signal_new ("XKB-per-client-flags-reply",

5322

G_TYPE_FROM_CLASS (klass),

5323

G_SIGNAL_RUN_LAST,

5324

G_STRUCT_OFFSET (XigCodecClass, XKB_per_client_flags_reply),

5325

NULL, NULL,

5326

g_cclosure_marshal_VOID__POINTER,

5327

G_TYPE_NONE, 1, G_TYPE_POINTER);

5328

signals[XKB_LIST_COMPONENTS] =

5329

g_signal_new ("XKB-list-components",

5330

G_TYPE_FROM_CLASS (klass),

5331

G_SIGNAL_RUN_LAST,

5332

G_STRUCT_OFFSET (XigCodecClass, XKB_list_components),

5333

NULL, NULL,

5334

g_cclosure_marshal_VOID__POINTER,

5335

G_TYPE_NONE, 1, G_TYPE_POINTER);

5336

signals[XKB_LIST_COMPONENTS_REPLY] =

5337

g_signal_new ("XKB-list-components-reply",

5338

G_TYPE_FROM_CLASS (klass),

5339

G_SIGNAL_RUN_LAST,

5340

G_STRUCT_OFFSET (XigCodecClass, XKB_list_components_reply),

5341

NULL, NULL,

5342

g_cclosure_marshal_VOID__POINTER,

5343

G_TYPE_NONE, 1, G_TYPE_POINTER);

5344

signals[XKB_GET_KBD_BY_NAME] =

5345

g_signal_new ("XKB-get-kbd-by-name",

5346

G_TYPE_FROM_CLASS (klass),

5347

G_SIGNAL_RUN_LAST,

5348

G_STRUCT_OFFSET (XigCodecClass, XKB_get_kbd_by_name),

5349

NULL, NULL,

5350

g_cclosure_marshal_VOID__POINTER,

5351

G_TYPE_NONE, 1, G_TYPE_POINTER);

5352

signals[XKB_GET_KBD_BY_NAME_REPLY] =

5353

g_signal_new ("XKB-get-kbd-by-name-reply",

5354

G_TYPE_FROM_CLASS (klass),

5355

G_SIGNAL_RUN_LAST,

5356

G_STRUCT_OFFSET (XigCodecClass, XKB_get_kbd_by_name_reply),

5357

NULL, NULL,

5358

g_cclosure_marshal_VOID__POINTER,

5359

G_TYPE_NONE, 1, G_TYPE_POINTER);

5360

signals[XKB_GET_DEVICE_INFO] =

5361

g_signal_new ("XKB-get-device-info",

5362

G_TYPE_FROM_CLASS (klass),

5363

G_SIGNAL_RUN_LAST,

5364

G_STRUCT_OFFSET (XigCodecClass, XKB_get_device_info),

5365

NULL, NULL,

5366

g_cclosure_marshal_VOID__POINTER,

5367

G_TYPE_NONE, 1, G_TYPE_POINTER);

5368

signals[XKB_GET_DEVICE_INFO_REPLY] =

5369

g_signal_new ("XKB-get-device-info-reply",

5370

G_TYPE_FROM_CLASS (klass),

5371

G_SIGNAL_RUN_LAST,

5372

G_STRUCT_OFFSET (XigCodecClass, XKB_get_device_info_reply),

5373

NULL, NULL,

5374

g_cclosure_marshal_VOID__POINTER,

5375

G_TYPE_NONE, 1, G_TYPE_POINTER);

5376

signals[XKB_SET_DEVICE_INFO] =

5377

g_signal_new ("XKB-set-device-info",

5378

G_TYPE_FROM_CLASS (klass),

5379

G_SIGNAL_RUN_LAST,

5380

G_STRUCT_OFFSET (XigCodecClass, XKB_set_device_info),

5381

NULL, NULL,

5382

g_cclosure_marshal_VOID__POINTER,

5383

G_TYPE_NONE, 1, G_TYPE_POINTER);

5384

signals[XKB_SET_DEBUGGING_FLAGS] =

5385

g_signal_new ("XKB-set-debugging-flags",

5386

G_TYPE_FROM_CLASS (klass),

5387

G_SIGNAL_RUN_LAST,

5388

G_STRUCT_OFFSET (XigCodecClass, XKB_set_debugging_flags),

5389

NULL, NULL,

5390

g_cclosure_marshal_VOID__POINTER,

5391

G_TYPE_NONE, 1, G_TYPE_POINTER);

5392

signals[XKB_SET_DEBUGGING_FLAGS_REPLY] =

5393

g_signal_new ("XKB-set-debugging-flags-reply",

5394

G_TYPE_FROM_CLASS (klass),

5395

G_SIGNAL_RUN_LAST,

5396

G_STRUCT_OFFSET (XigCodecClass, XKB_set_debugging_flags_reply),

5397

NULL, NULL,

5398

g_cclosure_marshal_VOID__POINTER,

5399

G_TYPE_NONE, 1, G_TYPE_POINTER);

5400

signals[RENDER_QUERY_VERSION] =

5401

g_signal_new ("RENDER-query-version",

5402

G_TYPE_FROM_CLASS (klass),

5403

G_SIGNAL_RUN_LAST,

5404

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_version),

5405

NULL, NULL,

5406

g_cclosure_marshal_VOID__POINTER,

5407

G_TYPE_NONE, 1, G_TYPE_POINTER);

5408

signals[RENDER_QUERY_VERSION_REPLY] =

5409

g_signal_new ("RENDER-query-version-reply",

5410

G_TYPE_FROM_CLASS (klass),

5411

G_SIGNAL_RUN_LAST,

5412

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_version_reply),

5413

NULL, NULL,

5414

g_cclosure_marshal_VOID__POINTER,

5415

G_TYPE_NONE, 1, G_TYPE_POINTER);

5416

signals[RENDER_QUERY_PICT_FORMATS] =

5417

g_signal_new ("RENDER-query-pict-formats",

5418

G_TYPE_FROM_CLASS (klass),

5419

G_SIGNAL_RUN_LAST,

5420

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_pict_formats),

5421

NULL, NULL,

5422

g_cclosure_marshal_VOID__POINTER,

5423

G_TYPE_NONE, 1, G_TYPE_POINTER);

5424

signals[RENDER_QUERY_PICT_FORMATS_REPLY] =

5425

g_signal_new ("RENDER-query-pict-formats-reply",

5426

G_TYPE_FROM_CLASS (klass),

5427

G_SIGNAL_RUN_LAST,

5428

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_pict_formats_reply),

5429

NULL, NULL,

5430

g_cclosure_marshal_VOID__POINTER,

5431

G_TYPE_NONE, 1, G_TYPE_POINTER);

5432

signals[RENDER_QUERY_PICT_INDEX_VALUES] =

5433

g_signal_new ("RENDER-query-pict-index-values",

5434

G_TYPE_FROM_CLASS (klass),

5435

G_SIGNAL_RUN_LAST,

5436

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_pict_index_values),

5437

NULL, NULL,

5438

g_cclosure_marshal_VOID__POINTER,

5439

G_TYPE_NONE, 1, G_TYPE_POINTER);

5440

signals[RENDER_QUERY_PICT_INDEX_VALUES_REPLY] =

5441

g_signal_new ("RENDER-query-pict-index-values-reply",

5442

G_TYPE_FROM_CLASS (klass),

5443

G_SIGNAL_RUN_LAST,

5444

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_pict_index_values_reply),

5445

NULL, NULL,

5446

g_cclosure_marshal_VOID__POINTER,

5447

G_TYPE_NONE, 1, G_TYPE_POINTER);

5448

signals[RENDER_CREATE_PICTURE] =

5449

g_signal_new ("RENDER-create-picture",

5450

G_TYPE_FROM_CLASS (klass),

5451

G_SIGNAL_RUN_LAST,

5452

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_picture),

5453

NULL, NULL,

5454

g_cclosure_marshal_VOID__POINTER,

5455

G_TYPE_NONE, 1, G_TYPE_POINTER);

5456

signals[RENDER_CHANGE_PICTURE] =

5457

g_signal_new ("RENDER-change-picture",

5458

G_TYPE_FROM_CLASS (klass),

5459

G_SIGNAL_RUN_LAST,

5460

G_STRUCT_OFFSET (XigCodecClass, RENDER_change_picture),

5461

NULL, NULL,

5462

g_cclosure_marshal_VOID__POINTER,

5463

G_TYPE_NONE, 1, G_TYPE_POINTER);

5464

signals[RENDER_SET_PICTURE_CLIP_RECTANGLES] =

5465

g_signal_new ("RENDER-set-picture-clip-rectangles",

5466

G_TYPE_FROM_CLASS (klass),

5467

G_SIGNAL_RUN_LAST,

5468

G_STRUCT_OFFSET (XigCodecClass, RENDER_set_picture_clip_rectangles),

5469

NULL, NULL,

5470

g_cclosure_marshal_VOID__POINTER,

5471

G_TYPE_NONE, 1, G_TYPE_POINTER);

5472

signals[RENDER_FREE_PICTURE] =

5473

g_signal_new ("RENDER-free-picture",

5474

G_TYPE_FROM_CLASS (klass),

5475

G_SIGNAL_RUN_LAST,

5476

G_STRUCT_OFFSET (XigCodecClass, RENDER_free_picture),

5477

NULL, NULL,

5478

g_cclosure_marshal_VOID__POINTER,

5479

G_TYPE_NONE, 1, G_TYPE_POINTER);

5480

signals[RENDER_COMPOSITE] =

5481

g_signal_new ("RENDER-composite",

5482

G_TYPE_FROM_CLASS (klass),

5483

G_SIGNAL_RUN_LAST,

5484

G_STRUCT_OFFSET (XigCodecClass, RENDER_composite),

5485

NULL, NULL,

5486

g_cclosure_marshal_VOID__POINTER,

5487

G_TYPE_NONE, 1, G_TYPE_POINTER);

5488

signals[RENDER_TRAPEZOIDS] =

5489

g_signal_new ("RENDER-trapezoids",

5490

G_TYPE_FROM_CLASS (klass),

5491

G_SIGNAL_RUN_LAST,

5492

G_STRUCT_OFFSET (XigCodecClass, RENDER_trapezoids),

5493

NULL, NULL,

5494

g_cclosure_marshal_VOID__POINTER,

5495

G_TYPE_NONE, 1, G_TYPE_POINTER);

5496

signals[RENDER_TRIANGLES] =

5497

g_signal_new ("RENDER-triangles",

5498

G_TYPE_FROM_CLASS (klass),

5499

G_SIGNAL_RUN_LAST,

5500

G_STRUCT_OFFSET (XigCodecClass, RENDER_triangles),

5501

NULL, NULL,

5502

g_cclosure_marshal_VOID__POINTER,

5503

G_TYPE_NONE, 1, G_TYPE_POINTER);

5504

signals[RENDER_TRI_STRIP] =

5505

g_signal_new ("RENDER-tri-strip",

5506

G_TYPE_FROM_CLASS (klass),

5507

G_SIGNAL_RUN_LAST,

5508

G_STRUCT_OFFSET (XigCodecClass, RENDER_tri_strip),

5509

NULL, NULL,

5510

g_cclosure_marshal_VOID__POINTER,

5511

G_TYPE_NONE, 1, G_TYPE_POINTER);

5512

signals[RENDER_TRI_FAN] =

5513

g_signal_new ("RENDER-tri-fan",

5514

G_TYPE_FROM_CLASS (klass),

5515

G_SIGNAL_RUN_LAST,

5516

G_STRUCT_OFFSET (XigCodecClass, RENDER_tri_fan),

5517

NULL, NULL,

5518

g_cclosure_marshal_VOID__POINTER,

5519

G_TYPE_NONE, 1, G_TYPE_POINTER);

5520

signals[RENDER_CREATE_GLYPH_SET] =

5521

g_signal_new ("RENDER-create-glyph-set",

5522

G_TYPE_FROM_CLASS (klass),

5523

G_SIGNAL_RUN_LAST,

5524

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_glyph_set),

5525

NULL, NULL,

5526

g_cclosure_marshal_VOID__POINTER,

5527

G_TYPE_NONE, 1, G_TYPE_POINTER);

5528

signals[RENDER_REFERENCE_GLYPH_SET] =

5529

g_signal_new ("RENDER-reference-glyph-set",

5530

G_TYPE_FROM_CLASS (klass),

5531

G_SIGNAL_RUN_LAST,

5532

G_STRUCT_OFFSET (XigCodecClass, RENDER_reference_glyph_set),

5533

NULL, NULL,

5534

g_cclosure_marshal_VOID__POINTER,

5535

G_TYPE_NONE, 1, G_TYPE_POINTER);

5536

signals[RENDER_FREE_GLYPH_SET] =

5537

g_signal_new ("RENDER-free-glyph-set",

5538

G_TYPE_FROM_CLASS (klass),

5539

G_SIGNAL_RUN_LAST,

5540

G_STRUCT_OFFSET (XigCodecClass, RENDER_free_glyph_set),

5541

NULL, NULL,

5542

g_cclosure_marshal_VOID__POINTER,

5543

G_TYPE_NONE, 1, G_TYPE_POINTER);

5544

signals[RENDER_ADD_GLYPHS] =

5545

g_signal_new ("RENDER-add-glyphs",

5546

G_TYPE_FROM_CLASS (klass),

5547

G_SIGNAL_RUN_LAST,

5548

G_STRUCT_OFFSET (XigCodecClass, RENDER_add_glyphs),

5549

NULL, NULL,

5550

g_cclosure_marshal_VOID__POINTER,

5551

G_TYPE_NONE, 1, G_TYPE_POINTER);

5552

signals[RENDER_FREE_GLYPHS] =

5553

g_signal_new ("RENDER-free-glyphs",

5554

G_TYPE_FROM_CLASS (klass),

5555

G_SIGNAL_RUN_LAST,

5556

G_STRUCT_OFFSET (XigCodecClass, RENDER_free_glyphs),

5557

NULL, NULL,

5558

g_cclosure_marshal_VOID__POINTER,

5559

G_TYPE_NONE, 1, G_TYPE_POINTER);

5560

signals[RENDER_COMPOSITE_GLYPHS8] =

5561

g_signal_new ("RENDER-composite-glyphs8",

5562

G_TYPE_FROM_CLASS (klass),

5563

G_SIGNAL_RUN_LAST,

5564

G_STRUCT_OFFSET (XigCodecClass, RENDER_composite_glyphs8),

5565

NULL, NULL,

5566

g_cclosure_marshal_VOID__POINTER,

5567

G_TYPE_NONE, 1, G_TYPE_POINTER);

5568

signals[RENDER_COMPOSITE_GLYPHS16] =

5569

g_signal_new ("RENDER-composite-glyphs16",

5570

G_TYPE_FROM_CLASS (klass),

5571

G_SIGNAL_RUN_LAST,

5572

G_STRUCT_OFFSET (XigCodecClass, RENDER_composite_glyphs16),

5573

NULL, NULL,

5574

g_cclosure_marshal_VOID__POINTER,

5575

G_TYPE_NONE, 1, G_TYPE_POINTER);

5576

signals[RENDER_COMPOSITE_GLYPHS32] =

5577

g_signal_new ("RENDER-composite-glyphs32",

5578

G_TYPE_FROM_CLASS (klass),

5579

G_SIGNAL_RUN_LAST,

5580

G_STRUCT_OFFSET (XigCodecClass, RENDER_composite_glyphs32),

5581

NULL, NULL,

5582

g_cclosure_marshal_VOID__POINTER,

5583

G_TYPE_NONE, 1, G_TYPE_POINTER);

5584

signals[RENDER_FILL_RECTANGLES] =

5585

g_signal_new ("RENDER-fill-rectangles",

5586

G_TYPE_FROM_CLASS (klass),

5587

G_SIGNAL_RUN_LAST,

5588

G_STRUCT_OFFSET (XigCodecClass, RENDER_fill_rectangles),

5589

NULL, NULL,

5590

g_cclosure_marshal_VOID__POINTER,

5591

G_TYPE_NONE, 1, G_TYPE_POINTER);

5592

signals[RENDER_CREATE_CURSOR] =

5593

g_signal_new ("RENDER-create-cursor",

5594

G_TYPE_FROM_CLASS (klass),

5595

G_SIGNAL_RUN_LAST,

5596

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_cursor),

5597

NULL, NULL,

5598

g_cclosure_marshal_VOID__POINTER,

5599

G_TYPE_NONE, 1, G_TYPE_POINTER);

5600

signals[RENDER_SET_PICTURE_TRANSFORM] =

5601

g_signal_new ("RENDER-set-picture-transform",

5602

G_TYPE_FROM_CLASS (klass),

5603

G_SIGNAL_RUN_LAST,

5604

G_STRUCT_OFFSET (XigCodecClass, RENDER_set_picture_transform),

5605

NULL, NULL,

5606

g_cclosure_marshal_VOID__POINTER,

5607

G_TYPE_NONE, 1, G_TYPE_POINTER);

5608

signals[RENDER_QUERY_FILTERS] =

5609

g_signal_new ("RENDER-query-filters",

5610

G_TYPE_FROM_CLASS (klass),

5611

G_SIGNAL_RUN_LAST,

5612

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_filters),

5613

NULL, NULL,

5614

g_cclosure_marshal_VOID__POINTER,

5615

G_TYPE_NONE, 1, G_TYPE_POINTER);

5616

signals[RENDER_QUERY_FILTERS_REPLY] =

5617

g_signal_new ("RENDER-query-filters-reply",

5618

G_TYPE_FROM_CLASS (klass),

5619

G_SIGNAL_RUN_LAST,

5620

G_STRUCT_OFFSET (XigCodecClass, RENDER_query_filters_reply),

5621

NULL, NULL,

5622

g_cclosure_marshal_VOID__POINTER,

5623

G_TYPE_NONE, 1, G_TYPE_POINTER);

5624

signals[RENDER_SET_PICTURE_FILTER] =

5625

g_signal_new ("RENDER-set-picture-filter",

5626

G_TYPE_FROM_CLASS (klass),

5627

G_SIGNAL_RUN_LAST,

5628

G_STRUCT_OFFSET (XigCodecClass, RENDER_set_picture_filter),

5629

NULL, NULL,

5630

g_cclosure_marshal_VOID__POINTER,

5631

G_TYPE_NONE, 1, G_TYPE_POINTER);

5632

signals[RENDER_CREATE_ANIM_CURSOR] =

5633

g_signal_new ("RENDER-create-anim-cursor",

5634

G_TYPE_FROM_CLASS (klass),

5635

G_SIGNAL_RUN_LAST,

5636

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_anim_cursor),

5637

NULL, NULL,

5638

g_cclosure_marshal_VOID__POINTER,

5639

G_TYPE_NONE, 1, G_TYPE_POINTER);

5640

signals[RENDER_ADD_TRAPS] =

5641

g_signal_new ("RENDER-add-traps",

5642

G_TYPE_FROM_CLASS (klass),

5643

G_SIGNAL_RUN_LAST,

5644

G_STRUCT_OFFSET (XigCodecClass, RENDER_add_traps),

5645

NULL, NULL,

5646

g_cclosure_marshal_VOID__POINTER,

5647

G_TYPE_NONE, 1, G_TYPE_POINTER);

5648

signals[RENDER_CREATE_SOLID_FILL] =

5649

g_signal_new ("RENDER-create-solid-fill",

5650

G_TYPE_FROM_CLASS (klass),

5651

G_SIGNAL_RUN_LAST,

5652

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_solid_fill),

5653

NULL, NULL,

5654

g_cclosure_marshal_VOID__POINTER,

5655

G_TYPE_NONE, 1, G_TYPE_POINTER);

5656

signals[RENDER_CREATE_LINEAR_GRADIENT] =

5657

g_signal_new ("RENDER-create-linear-gradient",

5658

G_TYPE_FROM_CLASS (klass),

5659

G_SIGNAL_RUN_LAST,

5660

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_linear_gradient),

5661

NULL, NULL,

5662

g_cclosure_marshal_VOID__POINTER,

5663

G_TYPE_NONE, 1, G_TYPE_POINTER);

5664

signals[RENDER_CREATE_RADIAL_GRADIENT] =

5665

g_signal_new ("RENDER-create-radial-gradient",

5666

G_TYPE_FROM_CLASS (klass),

5667

G_SIGNAL_RUN_LAST,

5668

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_radial_gradient),

5669

NULL, NULL,

5670

g_cclosure_marshal_VOID__POINTER,

5671

G_TYPE_NONE, 1, G_TYPE_POINTER);

5672

signals[RENDER_CREATE_CONICAL_GRADIENT] =

5673

g_signal_new ("RENDER-create-conical-gradient",

5674

G_TYPE_FROM_CLASS (klass),

5675

G_SIGNAL_RUN_LAST,

5676

G_STRUCT_OFFSET (XigCodecClass, RENDER_create_conical_gradient),

5677

NULL, NULL,

5678

g_cclosure_marshal_VOID__POINTER,

5679

G_TYPE_NONE, 1, G_TYPE_POINTER);

5680

}