Grcov report - my-atk-table.c

1

/*

2

 * Copyright 2008 Codethink Ltd.

3

 * Copyright (c) 2015 Samsung Electronics Co., Ltd.

4

5

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

6

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

7

 * License as published by the Free Software Foundation; either

8

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

9

10

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

11

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

12

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

13

 * Lesser General Public License for more details.

14

15

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

16

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

17

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

18

 * Boston, MA 02110-1301, USA.

19

*/

20

21

#include <atk/atk.h>

22

#include <glib.h>

23

#include <string.h>

24

25

#include "my-atk-object.h"

26

#include "my-atk-table-cell.h"

27

#include "my-atk-table.h"

28

29

typedef struct _MyAtkTableInfo MyAtkTableInfo;

30

31

static void GDestroyNotifyGPTRARRAYptrArray (gpointer data);

32

static void atk_table_interface_init (AtkTableIface *iface);

33

34

32

G_DEFINE_TYPE_WITH_CODE (MyAtkTable,

35

                         my_atk_table,

36

                         MY_TYPE_ATK_OBJECT,

37

                         G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE,

38

                                                atk_table_interface_init));

39

40

static gint

41

46

my_atk_table_get_index_at (AtkTable *obj, gint row, gint column)

42

43

46

  MyAtkTable *self = MY_ATK_TABLE (obj);

44

46

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

45

46

  gint i, all_child, index_first_cell = -1;

46

  gint ret = -1;

47

48

46

  all_child = MY_ATK_OBJECT (self)->children->len;

49

46

  AtkObject *child = NULL;

50

51

46

  MyAtkTableCell *cell = NULL;

52

1012

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

53

54

966

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

55

966

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_CELL)

56

57

552

          if (index_first_cell == -1)

58

59

46

              index_first_cell = i;

60

61

552

          cell = MY_ATK_TABLE_CELL (child);

62

552

          if (cell->x == column && cell->y == row)

63

64

46

              ret = i - index_first_cell;

65

66

67

68

46

  return ret;

69

70

71

static gint

72

4

my_atk_table_get_column_at_index (AtkTable *obj, gint index)

73

74

4

  MyAtkTable *table = MY_ATK_TABLE (obj);

75

4

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

76

4

  gint columns = -1;

77

4

  gint rows = -1;

78

  gint i, j;

79

80

4

  columns = atk_table_get_n_columns (ATK_TABLE (table));

81

4

  rows = atk_table_get_n_rows (ATK_TABLE (table));

82

83

7

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

84

85

19

      for (j = 0; j < columns; j++)

86

87

16

          if (index == my_atk_table_get_index_at (obj, i, j))

88

4

            return j;

89

90

91

  return -1;

92

93

94

static gint

95

5

my_atk_table_get_row_at_index (AtkTable *obj, gint index)

96

97

5

  MyAtkTable *table = MY_ATK_TABLE (obj);

98

5

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

99

5

  gint columns = -1;

100

5

  gint rows = -1;

101

  gint i, j;

102

103

5

  columns = atk_table_get_n_columns (ATK_TABLE (table));

104

5

  rows = atk_table_get_n_rows (ATK_TABLE (table));

105

106

11

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

107

108

33

      for (j = 0; j < columns; j++)

109

110

27

          if (index == my_atk_table_get_index_at (obj, i, j))

111

5

            return i;

112

113

114

115

  return -1;

116

117

118

static gint

119

18

my_atk_table_get_n_columns (AtkTable *obj)

120

121

18

  MyAtkTable *self = MY_ATK_TABLE (obj);

122

18

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

123

18

  gint i, all_child, ret = 0;

124

125

18

  all_child = MY_ATK_OBJECT (self)->children->len;

126

18

  AtkObject *child = NULL;

127

396

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

128

129

378

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

130

378

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

131

54

        ret++;

132

133

18

  return ret;

134

135

136

static gint

137

23

my_atk_table_get_n_rows (AtkTable *obj)

138

139

23

  MyAtkTable *self = MY_ATK_TABLE (obj);

140

23

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

141

23

  gint i, all_child, ret = 0;

142

143

23

  all_child = MY_ATK_OBJECT (self)->children->len;

144

23

  AtkObject *child = NULL;

145

506

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

146

147

483

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

148

483

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

149

92

        ret++;

150

151

23

  return ret;

152

153

154

static AtkObject *

155

1

my_atk_table_get_caption (AtkTable *obj)

156

157

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

158

159

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

160

  gint i, all_child;

161

1

  AtkObject *caption = NULL;

162

163

1

  all_child = MY_ATK_OBJECT (self)->children->len;

164

1

  AtkObject *child = NULL;

165

22

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

166

167

21

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

168

21

      if (atk_object_get_role (child) == ATK_ROLE_CAPTION)

169

1

        caption = child;

170

171

1

  return caption ? caption : NULL;

172

173

174

static AtkObject *

175

10

my_atk_table_ref_at (AtkTable *obj, gint row, gint column)

176

177

10

  MyAtkTable *self = MY_ATK_TABLE (obj);

178

10

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

179

  gint i, all_child;

180

10

  AtkObject *ret = NULL;

181

182

10

  all_child = MY_ATK_OBJECT (self)->children->len;

183

10

  AtkObject *child = NULL;

184

185

10

  MyAtkTableCell *cell = NULL;

186

220

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

187

188

210

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

189

210

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_CELL)

190

191

120

          cell = MY_ATK_TABLE_CELL (child);

192

120

          if (cell->x == column && cell->y == row)

193

10

            ret = ATK_OBJECT (cell);

194

195

196

10

  return ret ? ret : NULL;

197

198

199

static const gchar *

200

2

my_atk_table_get_row_description (AtkTable *obj, gint index)

201

202

2

  MyAtkTable *self = MY_ATK_TABLE (obj);

203

2

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

204

  gint i, all_child;

205

2

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj),

206

                                         g_object_unref);

207

208

2

  all_child = MY_ATK_OBJECT (self)->children->len;

209

2

  AtkObject *child = NULL;

210

211

44

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

212

213

42

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

214

42

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

215

8

        g_ptr_array_add (ret, child);

216

217

2

  child = g_ptr_array_index (ret, index);

218

219

4

  return g_strdup (atk_object_get_description (child));

220

221

222

static const gchar *

223

2

my_atk_table_get_column_description (AtkTable *obj, gint index)

224

225

2

  MyAtkTable *self = MY_ATK_TABLE (obj);

226

2

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

227

  gint i, all_child;

228

2

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_columns (obj), g_object_unref);

229

230

2

  all_child = MY_ATK_OBJECT (self)->children->len;

231

2

  AtkObject *child = NULL;

232

233

44

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

234

235

42

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

236

42

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

237

6

        g_ptr_array_add (ret, child);

238

239

2

  child = g_ptr_array_index (ret, index);

240

241

4

  return g_strdup (atk_object_get_description (child));

242

243

244

static gint

245

2

my_atk_table_test_table_get_row_extent_at (AtkTable *obj, gint row, gint col)

246

247

2

  AtkObject *cell = my_atk_table_ref_at (obj, row, col);

248

249

2

  MyAtkTableCell *self = MY_ATK_TABLE_CELL (cell);

250

251

2

  return self->row_span;

252

253

254

static gint

255

2

my_atk_table_test_table_get_column_extent_at (AtkTable *obj, gint row, gint col)

256

257

2

  AtkObject *cell = my_atk_table_ref_at (obj, row, col);

258

259

2

  MyAtkTableCell *self = MY_ATK_TABLE_CELL (cell);

260

261

2

  return self->column_span;

262

263

264

static AtkObject *

265

2

my_atk_table_get_row_header (AtkTable *obj, gint row)

266

267

2

  MyAtkTable *self = MY_ATK_TABLE (obj);

268

2

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

269

  gint i, all_child;

270

2

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);

271

272

2

  all_child = MY_ATK_OBJECT (self)->children->len;

273

2

  AtkObject *child = NULL;

274

2

  AtkObject *c = NULL;

275

276

44

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

277

278

42

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

279

42

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

280

8

        g_ptr_array_add (ret, child);

281

282

2

  c = ATK_OBJECT (g_ptr_array_index (ret, row));

283

284

2

  return atk_object_ref_accessible_child (c, 0);

285

286

287

static AtkObject *

288

3

my_atk_table_get_column_header (AtkTable *obj, gint col)

289

290

3

  MyAtkTable *self = MY_ATK_TABLE (obj);

291

3

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

292

  gint i, all_child;

293

3

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);

294

295

3

  all_child = MY_ATK_OBJECT (self)->children->len;

296

3

  AtkObject *child = NULL;

297

3

  AtkObject *c = NULL;

298

299

66

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

300

301

63

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

302

63

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

303

9

        g_ptr_array_add (ret, child);

304

305

3

  c = g_ptr_array_index (ret, col);

306

307

3

  return atk_object_ref_accessible_child (c, 0);

308

309

310

gint

311

2

my_atk_table_get_selected_rows (AtkTable *obj, gint **selected)

312

313

2

  MyAtkTable *self = MY_ATK_TABLE (obj);

314

2

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

315

2

  gint i, all_child, row = 0, ret = 0;

316

2

  AtkObject *child = NULL;

317

2

  AtkStateSet *ss = NULL;

318

319

2

  GArray *array = g_array_new (FALSE, FALSE, sizeof (gint));

320

321

2

  all_child = MY_ATK_OBJECT (self)->children->len;

322

44

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

323

324

42

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

325

42

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

326

327

8

          ss = atk_object_ref_state_set (child);

328

8

          if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

329

330

4

              ret++;

331

4

              g_array_append_val (array, row);

332

333

8

          row++;

334

335

336

2

  if (selected)

337

2

    *selected = (gint *) g_array_free (array, FALSE);

338

2

  return ret;

339

340

341

gint

342

2

my_atk_table_get_selected_columns (AtkTable *obj, gint **selected)

343

344

2

  MyAtkTable *self = MY_ATK_TABLE (obj);

345

2

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);

346

2

  gint i, all_child, column = 0, ret = 0;

347

2

  AtkObject *child = NULL;

348

2

  AtkStateSet *ss = NULL;

349

350

2

  GArray *array = g_array_new (FALSE, FALSE, sizeof (gint));

351

352

2

  all_child = MY_ATK_OBJECT (self)->children->len;

353

44

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

354

355

42

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

356

42

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

357

358

6

          ss = atk_object_ref_state_set (child);

359

6

          if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

360

361

2

              ret++;

362

2

              g_array_append_val (array, column);

363

364

6

          column++;

365

366

367

2

  if (selected)

368

2

    *selected = (gint *) g_array_free (array, FALSE);

369

2

  return ret;

370

371

372

static gboolean

373

6

my_atk_table_is_row_selected (AtkTable *obj, gint row)

374

375

6

  MyAtkTable *self = MY_ATK_TABLE (obj);

376

6

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

377

  gint i, all_child;

378

6

  AtkObject *child = NULL;

379

6

  AtkObject *c = NULL;

380

6

  AtkStateSet *ss = NULL;

381

6

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);

382

383

6

  all_child = MY_ATK_OBJECT (self)->children->len;

384

132

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

385

386

126

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

387

126

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

388

24

        g_ptr_array_add (ret, child);

389

390

6

  c = g_ptr_array_index (ret, row);

391

6

  ss = atk_object_ref_state_set (c);

392

6

  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

393

3

    return TRUE;

394

3

  return FALSE;

395

396

397

static gboolean

398

6

my_atk_table_is_column_selected (AtkTable *obj, gint col)

399

400

6

  MyAtkTable *self = MY_ATK_TABLE (obj);

401

6

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

402

  gint i, all_child;

403

6

  AtkObject *child = NULL;

404

6

  AtkObject *c = NULL;

405

6

  AtkStateSet *ss = NULL;

406

6

  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_columns (obj), g_object_unref);

407

408

6

  all_child = MY_ATK_OBJECT (self)->children->len;

409

132

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

410

411

126

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

412

126

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

413

18

        g_ptr_array_add (ret, child);

414

415

6

  c = g_ptr_array_index (ret, col);

416

6

  ss = atk_object_ref_state_set (c);

417

6

  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

418

3

    return TRUE;

419

3

  return FALSE;

420

421

422

static gboolean

423

3

my_atk_table_is_selected (AtkTable *obj, gint row, gint col)

424

425

3

  AtkObject *cell = atk_table_ref_at (obj, row, col);

426

3

  AtkStateSet *ss = atk_object_ref_state_set (cell);

427

3

  gboolean ret = FALSE;

428

429

3

  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

430

1

    ret = TRUE;

431

3

  return ret;

432

433

434

static gboolean

435

1

my_atk_table_add_column_selection (AtkTable *obj, gint col)

436

437

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

438

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

439

1

  gint i, all_child, counter = 0;

440

1

  AtkObject *child = NULL;

441

1

  AtkStateSet *ss = NULL;

442

443

1

  all_child = MY_ATK_OBJECT (self)->children->len;

444

5

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

445

446

5

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

447

5

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

448

449

3

          if (col == counter)

450

451

1

              ss = atk_object_ref_state_set (child);

452

1

              if (!atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

453

454

1

                  atk_state_set_add_state (ss, ATK_STATE_SELECTED);

455

1

                  return TRUE;

456

457

458

2

          counter++;

459

460

461

  return FALSE;

462

463

464

static gboolean

465

1

my_atk_table_add_row_selection (AtkTable *obj, gint row)

466

467

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

468

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

469

1

  gint i, all_child, counter = 0;

470

1

  AtkObject *child = NULL;

471

1

  AtkStateSet *ss = NULL;

472

473

1

  all_child = MY_ATK_OBJECT (self)->children->len;

474

7

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

475

476

7

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

477

7

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

478

479

2

          if (row == counter)

480

481

1

              ss = atk_object_ref_state_set (child);

482

1

              if (!atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

483

484

1

                  atk_state_set_add_state (ss, ATK_STATE_SELECTED);

485

1

                  return TRUE;

486

487

488

1

          counter++;

489

490

491

  return FALSE;

492

493

494

static gboolean

495

1

my_atk_table_remove_column_selection (AtkTable *obj, gint col)

496

497

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

498

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

499

1

  gint i, all_child, counter = 0;

500

1

  AtkObject *child = NULL;

501

1

  AtkStateSet *ss = NULL;

502

503

1

  all_child = MY_ATK_OBJECT (self)->children->len;

504

4

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

505

506

4

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

507

4

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)

508

509

2

          if (col == counter)

510

511

1

              ss = atk_object_ref_state_set (child);

512

1

              if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

513

514

1

                  atk_state_set_remove_state (ss, ATK_STATE_SELECTED);

515

1

                  return TRUE;

516

517

518

1

          counter++;

519

520

521

  return FALSE;

522

523

524

static gboolean

525

1

my_atk_table_remove_row_selection (AtkTable *obj, gint row)

526

527

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

528

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);

529

1

  gint i, all_child, counter = 0;

530

1

  AtkObject *child = NULL;

531

1

  AtkStateSet *ss = NULL;

532

533

1

  all_child = MY_ATK_OBJECT (self)->children->len;

534

8

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

535

536

8

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

537

8

      if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)

538

539

3

          if (row == counter)

540

541

1

              ss = atk_object_ref_state_set (child);

542

1

              if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))

543

544

1

                  atk_state_set_remove_state (ss, ATK_STATE_SELECTED);

545

1

                  return TRUE;

546

547

548

2

          counter++;

549

550

551

  return FALSE;

552

553

554

static AtkObject *

555

1

my_atk_table_get_summary (AtkTable *obj)

556

557

1

  MyAtkTable *self = MY_ATK_TABLE (obj);

558

1

  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);

559

  gint i, all_child;

560

1

  AtkObject *summary = NULL;

561

562

1

  all_child = MY_ATK_OBJECT (self)->children->len;

563

1

  AtkObject *child = NULL;

564

22

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

565

566

21

      child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);

567

21

      if (atk_object_get_role (child) == ATK_ROLE_HEADING)

568

1

        summary = child;

569

570

1

  return summary ? summary : NULL;

571

572

573

static void

574

my_atk_table_set_column_header (AtkTable *obj, gint column, AtkObject *header)

575

576

577

578

static void

579

my_atk_table_set_column_description (AtkTable *obj, gint column, const gchar *desc)

580

581

582

583

static void

584

my_atk_table_set_caption (AtkTable *obj, AtkObject *caption)

585

586

587

588

static void

589

my_atk_table_set_row_description (AtkTable *obj, gint row, const gchar *desc)

590

591

592

593

static void

594

my_atk_table_set_row_header (AtkTable *obj, gint column, AtkObject *header)

595

596

597

598

static void

599

my_atk_table_set_summary (AtkTable *table, AtkObject *accessible)

600

601

602

603

static void

604

my_atk_table_row_inserted (AtkTable *table, gint row, gint num_inserted)

605

606

607

608

static void

609

my_atk_table_column_inserted (AtkTable *table, gint column, gint num_inserted)

610

611

612

613

static void

614

my_atk_table_row_deleted (AtkTable *table, gint row, gint num_deleted)

615

616

617

618

static void

619

my_atk_table_column_deleted (AtkTable *table, gint column, gint num_deleted)

620

621

622

623

static void

624

my_atk_table_row_reordered (AtkTable *table)

625

626

627

628

static void

629

my_atk_table_column_reordered (AtkTable *table)

630

631

632

633

static void

634

my_atk_table_model_changed (AtkTable *table)

635

636

637

638

static void

639

32

atk_table_interface_init (AtkTableIface *iface)

640

641

642

32

  if (!iface)

643

    return;

644

645

32

  iface->ref_at = my_atk_table_ref_at;

646

647

  /* DEPRICATED BUT NOT IN ATSPI */

648

32

  iface->get_index_at = my_atk_table_get_index_at;

649

32

  iface->get_column_at_index = my_atk_table_get_column_at_index;

650

32

  iface->get_row_at_index = my_atk_table_get_row_at_index;

651

  /* DEPRICATED */

652

653

32

  iface->get_n_columns = my_atk_table_get_n_columns;

654

32

  iface->get_n_rows = my_atk_table_get_n_rows;

655

32

  iface->get_column_extent_at = my_atk_table_test_table_get_column_extent_at;

656

32

  iface->get_row_extent_at = my_atk_table_test_table_get_row_extent_at;

657

32

  iface->get_caption = my_atk_table_get_caption;

658

32

  iface->get_column_description = my_atk_table_get_column_description;

659

32

  iface->get_column_header = my_atk_table_get_column_header;

660

32

  iface->get_row_description = my_atk_table_get_row_description;

661

32

  iface->get_row_header = my_atk_table_get_row_header;

662

32

  iface->get_summary = my_atk_table_get_summary;

663

32

  iface->set_caption = my_atk_table_set_caption;

664

32

  iface->set_column_description = my_atk_table_set_column_description;

665

32

  iface->set_column_header = my_atk_table_set_column_header;

666

32

  iface->set_row_description = my_atk_table_set_row_description;

667

32

  iface->set_row_header = my_atk_table_set_row_header;

668

32

  iface->set_summary = my_atk_table_set_summary;

669

32

  iface->get_selected_columns = my_atk_table_get_selected_columns;

670

32

  iface->get_selected_rows = my_atk_table_get_selected_rows;

671

32

  iface->is_column_selected = my_atk_table_is_column_selected;

672

32

  iface->is_row_selected = my_atk_table_is_row_selected;

673

32

  iface->is_selected = my_atk_table_is_selected;

674

32

  iface->add_row_selection = my_atk_table_add_row_selection;

675

32

  iface->remove_row_selection = my_atk_table_remove_row_selection;

676

32

  iface->add_column_selection = my_atk_table_add_column_selection;

677

32

  iface->remove_column_selection = my_atk_table_remove_column_selection;

678

32

  iface->row_inserted = my_atk_table_row_inserted;

679

32

  iface->column_inserted = my_atk_table_column_inserted;

680

32

  iface->row_deleted = my_atk_table_row_deleted;

681

32

  iface->column_deleted = my_atk_table_column_deleted;

682

32

  iface->row_reordered = my_atk_table_row_reordered;

683

32

  iface->column_reordered = my_atk_table_column_reordered;

684

32

  iface->model_changed = my_atk_table_model_changed;

685

686

687

static void

688

32

my_atk_table_init (MyAtkTable *self)

689

690

32

  self->parent_table = NULL;

691

32

  self->table = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);

692

32

  self->row_header = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);

693

32

  self->column_headers = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);

694

32

  self->selected = FALSE;

695

32

  self->col_desc = NULL;

696

32

697

698

static void

699

GDestroyNotifyGPTRARRAYptrArray (gpointer data)

700

701

  g_ptr_array_free (data, TRUE);

702

703

704

static void

705

my_atk_table_class_initialize (AtkObject *obj, gpointer data)

706

707

708

709

static void

710

my_atk_table_class_finalize (GObject *obj)

711

712

713

714

static void

715

32

my_atk_table_class_init (MyAtkTableClass *my_class)

716

717

32

  AtkObjectClass *atk_class = ATK_OBJECT_CLASS (my_class);

718

32

  GObjectClass *gobject_class = G_OBJECT_CLASS (my_class);

719

720

32

  gobject_class->finalize = my_atk_table_class_finalize;

721

722

32

  atk_class->initialize = my_atk_table_class_initialize;

723

32