~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

#define FILTER_LEVEL_PARENT_ELT(level) (&g_array_index (FILTER_LEVEL ((level))->parent_level->array, FilterElt, FILTER_LEVEL ((level))->parent_elt_index))

133

#define FILTER_LEVEL_ELT_INDEX(level, elt) (FILTER_ELT ((elt)) - FILTER_ELT (FILTER_LEVEL ((level))->array->data))

134

132

135

/* general code (object/interface init, properties, etc) */

133

136

static void gtk_tree_model_filter_tree_model_init (GtkTreeModelIface *iface);

134

137

static void gtk_tree_model_filter_drag_source_init (GtkTreeDragSourceIface *iface);

214

217

/* private functions */

215

218

static void gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,

216

219

FilterLevel *parent_level,

217

FilterElt *parent_elt,

220

gint parent_elt_index,

218

221

gboolean emit_inserted);

219

222

220

223

static void gtk_tree_model_filter_free_level (GtkTreeModelFilter *filter,

257

260

static FilterElt *gtk_tree_model_filter_get_nth (GtkTreeModelFilter *filter,

258

261

FilterLevel *level,

259

262

int n);

263

static gboolean gtk_tree_model_filter_elt_is_visible_in_target (FilterLevel *level,

264

FilterElt *elt);

260

265

static FilterElt *gtk_tree_model_filter_get_nth_visible (GtkTreeModelFilter *filter,

261

266

FilterLevel *level,

262

267

int n);

436

441

static void

437

442

gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,

438

443

FilterLevel *parent_level,

439

FilterElt *parent_elt,

444

gint parent_elt_index,

440

445

gboolean emit_inserted)

441

446

{

442

447

GtkTreeIter iter;

443

448

GtkTreeIter first_node;

444

449

GtkTreeIter root;

450

FilterElt *parent_elt = NULL;

445

451

FilterLevel *new_level;

446

452

gint length = 0;

447

453

gint i;

474

480

GtkTreeIter parent_iter;

475

481

GtkTreeIter child_parent_iter;

476

482

483

parent_elt = &g_array_index (parent_level->array, FilterElt, parent_elt_index);

484

477

485

parent_iter.stamp = filter->priv->stamp;

478

486

parent_iter.user_data = parent_level;

479

487

parent_iter.user_data2 = parent_elt;

499

507

length);

500

508

new_level->ref_count = 0;

501

509

new_level->visible_nodes = 0;

502

new_level->parent_elt = parent_elt;

510

new_level->parent_elt_index = parent_elt_index;

503

511

new_level->parent_level = parent_level;

504

512

505

if (parent_elt)

513

if (parent_elt_index >= 0)

506

514

parent_elt->children = new_level;

507

515

else

508

516

filter->priv->root = new_level;

510

518

/* increase the count of zero ref_counts */

511

519

while (parent_level)

512

520

{

513

parent_elt->zero_ref_count++;

521

g_array_index (parent_level->array, FilterElt, parent_elt_index).zero_ref_count++;

514

522

515

parent_elt = parent_level->parent_elt;

523

parent_elt_index = parent_level->parent_elt_index;

516

524

parent_level = parent_level->parent_level;

517

525

}

518

526

if (new_level != filter->priv->root)

626

634

if (filter_level->ref_count == 0)

627

635

{

628

636

FilterLevel *parent_level = filter_level->parent_level;

629

FilterElt *parent_elt = filter_level->parent_elt;

637

gint parent_elt_index = filter_level->parent_elt_index;

630

638

631

639

while (parent_level)

632

640

{

633

parent_elt->zero_ref_count--;

641

g_array_index (parent_level->array, FilterElt, parent_elt_index).zero_ref_count--;

634

642

635

parent_elt = parent_level->parent_elt;

643

parent_elt_index = parent_level->parent_elt_index;

636

644

parent_level = parent_level->parent_level;

637

645

}

638

646

640

648

filter->priv->zero_ref_count--;

641

649

}

642

650

643

if (filter_level->parent_elt)

644

filter_level->parent_elt->children = NULL;

651

if (filter_level->parent_elt_index >= 0)

652

FILTER_LEVEL_PARENT_ELT (filter_level)->children = NULL;

645

653

else

646

654

filter->priv->root = NULL;

647

655

672

680

{

673

681

gtk_tree_path_prepend_index (path, walker2->offset);

674

682

675

walker2 = walker->parent_elt;

683

if (!walker->parent_level)

684

break;

685

686

walker2 = FILTER_LEVEL_PARENT_ELT (walker);

676

687

walker = walker->parent_level;

677

688

}

678

689

804

815

return &g_array_index (level->array, FilterElt, n);

805

816

}

806

817

818

static gboolean

819

gtk_tree_model_filter_elt_is_visible_in_target (FilterLevel *level,

820

FilterElt *elt)

821

{

822

gint elt_index;

823

824

if (!elt->visible)

825

return FALSE;

826

827

if (level->parent_elt_index == -1)

828

return TRUE;

829

830

831

{

832

elt_index = level->parent_elt_index;

833

level = level->parent_level;

834

835

if (elt_index >= 0

836

&& !g_array_index (level->array, FilterElt, elt_index).visible)

837

return FALSE;

838

}

839

while (level);

840

841

return TRUE;

842

}

843

807

844

static FilterElt *

808

845

gtk_tree_model_filter_get_nth_visible (GtkTreeModelFilter *filter,

809

846

FilterLevel *level,

848

885

FilterElt elt;

849

886

850

887

/* check if child exists and is visible */

851

if (level->parent_elt)

888

if (level->parent_elt_index >= 0)

852

889

{

853

890

c_parent_path =

854

891

gtk_tree_model_filter_elt_get_path (level->parent_level,

855

level->parent_elt,

892

FILTER_LEVEL_PARENT_ELT (level),

856

893

filter->priv->virtual_root);

857

894

if (!c_parent_path)

858

895

return NULL;

931

968

{

932

969

FilterElt *e = &(g_array_index (level->array, FilterElt, i));

933

970

if (e->children)

934

e->children->parent_elt = e;

971

e->children->parent_elt_index = i;

935

972

}

936

973

937

974

c_iter.stamp = filter->priv->stamp;

950

987

{

951

988

FilterElt *elt, *parent;

952

989

FilterLevel *level, *parent_level;

953

gint i, length;

990

gint i, length, parent_elt_index;

954

991

955

992

gboolean emit_child_toggled = FALSE;

956

993

957

994

level = FILTER_LEVEL (iter->user_data);

958

995

elt = FILTER_ELT (iter->user_data2);

959

996

960

parent = level->parent_elt;

997

parent_elt_index = level->parent_elt_index;

998

if (parent_elt_index >= 0)

999

parent = FILTER_LEVEL_PARENT_ELT (level);

1000

else

1001

parent = NULL;

961

1002

parent_level = level->parent_level;

962

1003

963

1004

length = level->array->len;

972

1013

* if level != root level and visible nodes == 0, emit row-has-child-toggled.

973

1014

974

1015

975

if (level != filter->priv->root && level->visible_nodes == 0)

1016

if (level != filter->priv->root

1017

&& level->visible_nodes == 0

1018

&& parent

1019

&& parent->visible)

976

1020

emit_child_toggled = TRUE;

977

1021

978

1022

if (length > 1)

980

1024

GtkTreePath *path;

981

1025

FilterElt *tmp;

982

1026

983

/* we emit row-deleted, and remove the node from the cache.

1027

/* We emit row-deleted, and remove the node from the cache.

1028

* If it has any children, these will be removed here as well.

984

1029

985

1030

1031

if (elt->children)

1032

gtk_tree_model_filter_free_level (filter, elt->children);

1033

986

1034

path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);

987

1035

elt->visible = FALSE;

988

1036

gtk_tree_model_filter_increment_stamp (filter);

1015

1063

1016

1064

elt = &g_array_index (level->array, FilterElt, i);

1017

1065

if (elt->children)

1018

elt->children->parent_elt = elt;

1066

elt->children->parent_elt_index = i;

1019

1067

}

1020

1068

}

1021

1069

}

1024

1072

{

1025

1073

GtkTreePath *path;

1026

1074

1027

/* we emit row-deleted, but keep the node in the cache and

1028

* referenced.

1075

/* We emit row-deleted, but keep the node in the cache and

1076

* referenced. Its children will be removed.

1029

1077

1030

1078

1079

if (elt->children)

1080

{

1081

gtk_tree_model_filter_free_level (filter, elt->children);

1082

elt->children = NULL;

1083

}

1084

1031

1085

path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);

1032

1086

elt->visible = FALSE;

1033

1087

gtk_tree_model_filter_increment_stamp (filter);

1038

1092

{

1039

1093

GtkTreePath *path;

1040

1094

1041

/* blow level away */

1095

/* Blow level away, including any child levels */

1042

1096

1043

1097

path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);

1044

1098

elt->visible = FALSE;

1230

1284

1231

1285

gtk_tree_path_free (path);

1232

1286

path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);

1233

gtk_tree_model_row_changed (GTK_TREE_MODEL (filter), path, &iter);

1234

1287

1235

1288

level = FILTER_LEVEL (iter.user_data);

1236

1289

elt = FILTER_ELT (iter.user_data2);

1237

1290

1238

/* and update the children */

1239

if (gtk_tree_model_iter_children (c_model, &children, &real_c_iter))

1240

gtk_tree_model_filter_update_children (filter, level, elt);

1291

if (gtk_tree_model_filter_elt_is_visible_in_target (level, elt))

1292

{

1293

gtk_tree_model_row_changed (GTK_TREE_MODEL (filter), path, &iter);

1294

1295

/* and update the children */

1296

if (gtk_tree_model_iter_children (c_model, &children, &real_c_iter))

1297

gtk_tree_model_filter_update_children (filter, level, elt);

1298

}

1241

1299

1242

1300

goto done;

1243

1301

}

1250

1308

/* make sure the new item has been pulled in */

1251

1309

if (!filter->priv->root)

1252

1310

{

1253

gint i;

1254

1311

FilterLevel *root;

1255

1312

1256

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

1313

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

1257

1314

1258

1315

root = FILTER_LEVEL (filter->priv->root);

1259

1260

if (root)

1261

{

1262

for (i = 0; i < root->array->len; i++)

1263

g_array_index (root->array, FilterElt, i).visible = FALSE;

1264

root->visible_nodes = 0;

1265

}

1266

1316

}

1267

1317

1268

1318

gtk_tree_model_filter_increment_stamp (filter);

1269

1319

1320

/* We need to allow to build new levels, because we are then pulling

1321

* in a child in an invisible level. We only want to find path if it

1322

* is in a visible level (and thus has a parent that is visible).

1323

1270

1324

if (!path)

1271

1325

path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,

1272

1326

c_path,

1273

TRUE,

1327

FALSE,

1274

1328

TRUE);

1275

1329

1276

1330

if (!path)

1289

1343

level->visible_nodes++;

1290

1344

}

1291

1345

1292

if ((level->parent_elt && level->parent_elt->visible) || !level->parent_elt)

1346

if (gtk_tree_model_filter_elt_is_visible_in_target (level, elt))

1293

1347

{

1294

1348

/* visibility changed -- reget path */

1295

1349

gtk_tree_path_free (path);

1297

1351

1298

1352

gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);

1299

1353

1354

if (level->parent_level && level->visible_nodes == 1)

1355

{

1356

/* We know that this is the first visible node in this level, so

1357

* we need to emit row-has-child-toggled on the parent. This

1358

* does not apply to the root level.

1359

1360

1361

gtk_tree_path_up (path);

1362

gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);

1363

1364

gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),

1365

path,

1366

&iter);

1367

}

1368

1300

1369

if (gtk_tree_model_iter_children (c_model, &children, c_iter))

1301

1370

gtk_tree_model_filter_update_children (filter, level, elt);

1302

1371

}

1379

1448

goto done;

1380

1449

1381

1450

/* build level will pull in the new child */

1382

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

1451

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

1383

1452

1384

1453

if (filter->priv->root

1385

1454

&& FILTER_LEVEL (filter->priv->root)->visible_nodes)

1506

1575

{

1507

1576

FilterElt *e = &g_array_index (level->array, FilterElt, i);

1508

1577

if (e->children)

1509

e->children->parent_elt = e;

1578

e->children->parent_elt_index = i;

1510

1579

}

1511

1580

1512

1581

/* don't emit the signal if we aren't visible */

1555

1624

GtkTreeIter iter;

1556

1625

FilterLevel *level;

1557

1626

FilterElt *elt;

1627

gboolean requested_state;

1558

1628

1559

1629

g_return_if_fail (c_path != NULL && c_iter != NULL);

1560

1630

1564

1634

if (filter->priv->virtual_root && !filter->priv->root

1565

1635

&& !gtk_tree_path_compare (c_path, filter->priv->virtual_root))

1566

1636

{

1567

gtk_tree_model_filter_build_level (filter, NULL, NULL, TRUE);

1637

gtk_tree_model_filter_build_level (filter, NULL, -1, TRUE);

1568

1638

return;

1569

1639

}

1570

1640

1571

if (!gtk_tree_model_filter_visible (filter, c_iter))

1572

return;

1641

/* For all other levels, there is a chance that the visibility state

1642

* of the parent has changed now.

1643

1573

1644

1574

1645

path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,

1575

1646

c_path,

1580

1651

1581

1652

gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (data), &iter, path);

1582

1653

1583

gtk_tree_path_free (path);

1584

1585

1654

level = FILTER_LEVEL (iter.user_data);

1586

1655

elt = FILTER_ELT (iter.user_data2);

1587

1656

1588

g_assert (elt->visible);

1657

gtk_tree_path_free (path);

1658

1659

requested_state = gtk_tree_model_filter_visible (filter, c_iter);

1660

1661

if (!elt->visible && !requested_state)

1662

{

1663

/* The parent node currently is not visible and will not become

1664

* visible, so we will not pass on the row-has-child-toggled event.

1665

1666

return;

1667

}

1668

else if (elt->visible && !requested_state)

1669

{

1670

/* The node is no longer visible, so it has to be removed.

1671

* _remove_node() takes care of emitting row-has-child-toggled

1672

* when required.

1673

1674

level->visible_nodes--;

1675

1676

gtk_tree_model_filter_remove_node (filter, &iter);

1677

1678

return;

1679

}

1680

else if (!elt->visible && requested_state)

1681

{

1682

elt->visible = TRUE;

1683

level->visible_nodes++;

1684

1685

/* Only insert if the parent is visible in the target */

1686

if (gtk_tree_model_filter_elt_is_visible_in_target (level, elt))

1687

{

1688

path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);

1689

gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);

1690

gtk_tree_path_free (path);

1691

1692

/* We do not update children now, because that will happen

1693

* below.

1694

1695

}

1696

}

1697

/* For the remaining possibility, elt->visible && requested_state

1698

* no action is required.

1699

1589

1700

1590

1701

/* If this node is referenced and has children, build the level so we

1591

1702

* can monitor it for changes.

1592

1703

1593

1704

if (elt->ref_count > 1 && gtk_tree_model_iter_has_child (c_model, c_iter))

1594

gtk_tree_model_filter_build_level (filter, level, elt, TRUE);

1705

gtk_tree_model_filter_build_level (filter, level,

1706

FILTER_LEVEL_ELT_INDEX (level, elt),

1707

TRUE);

1595

1708

1596

1709

/* get a path taking only visible nodes into account */

1597

1710

path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter);

1607

1720

GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);

1608

1721

GtkTreePath *path;

1609

1722

GtkTreeIter iter;

1610

FilterElt *elt, *parent = NULL;

1723

FilterElt *elt;

1611

1724

FilterLevel *level, *parent_level = NULL;

1612

1725

gboolean emit_child_toggled = FALSE;

1613

1726

gint offset;

1614

1727

gint i;

1728

gint parent_elt_index = -1;

1615

1729

1616

1730

g_return_if_fail (c_path != NULL);

1617

1731

1749

1863

if (elt->offset > offset)

1750

1864

elt->offset--;

1751

1865

if (elt->children)

1752

elt->children->parent_elt = elt;

1866

elt->children->parent_elt_index = i;

1753

1867

}

1754

1868

1755

1869

return;

1774

1888

{

1775

1889

emit_child_toggled = TRUE;

1776

1890

parent_level = level->parent_level;

1777

parent = level->parent_elt;

1891

parent_elt_index = level->parent_elt_index;

1778

1892

}

1779

1893

1780

1894

/* emit row_deleted */

1819

1933

if (elt->offset > offset)

1820

1934

elt->offset--;

1821

1935

if (elt->children)

1822

elt->children->parent_elt = elt;

1936

elt->children->parent_elt_index = i;

1823

1937

}

1824

1938

}

1825

1939

1830

1944

1831

1945

iter.stamp = filter->priv->stamp;

1832

1946

iter.user_data = parent_level;

1833

iter.user_data2 = parent;

1947

iter.user_data2 = &g_array_index (parent_level->array, FilterElt, parent_elt_index);

1834

1948

1835

1949

/* We set in_row_deleted to TRUE to avoid a level build triggered

1836

1950

* by row-has-child-toggled (parent model could call iter_has_child

2013

2127

{

2014

2128

FilterElt *e = &g_array_index (level->array, FilterElt, i);

2015

2129

if (e->children)

2016

e->children->parent_elt = e;

2130

e->children->parent_elt_index = i;

2017

2131

}

2018

2132

2019

2133

/* emit rows_reordered */

2114

2228

indices = gtk_tree_path_get_indices (path);

2115

2229

2116

2230

if (filter->priv->root == NULL)

2117

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

2231

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

2118

2232

level = FILTER_LEVEL (filter->priv->root);

2119

2233

2120

2234

depth = gtk_tree_path_get_depth (path);

2134

2248

elt = gtk_tree_model_filter_get_nth (filter, level, indices[i]);

2135

2249

2136

2250

if (!elt->children)

2137

gtk_tree_model_filter_build_level (filter, level, elt, FALSE);

2251

gtk_tree_model_filter_build_level (filter, level,

2252

FILTER_LEVEL_ELT_INDEX (level, elt),

2253

FALSE);

2138

2254

level = elt->children;

2139

2255

}

2140

2256

2169

2285

indices = gtk_tree_path_get_indices (path);

2170

2286

2171

2287

if (filter->priv->root == NULL)

2172

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

2288

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

2173

2289

level = FILTER_LEVEL (filter->priv->root);

2174

2290

2175

2291

depth = gtk_tree_path_get_depth (path);

2189

2305

elt = gtk_tree_model_filter_get_nth_visible (filter, level, indices[i]);

2190

2306

2191

2307

if (!elt->children)

2192

gtk_tree_model_filter_build_level (filter, level, elt, FALSE);

2308

gtk_tree_model_filter_build_level (filter, level,

2309

FILTER_LEVEL_ELT_INDEX (level, elt),

2310

FALSE);

2193

2311

level = elt->children;

2194

2312

}

2195

2313

2216

2334

GtkTreePath *retval;

2217

2335

FilterLevel *level;

2218

2336

FilterElt *elt;

2337

gint elt_index;

2219

2338

2220

2339

g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), NULL);

2221

2340

g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, NULL);

2223

2342

2224

2343

level = iter->user_data;

2225

2344

elt = iter->user_data2;

2345

elt_index = FILTER_LEVEL_ELT_INDEX (level, elt);

2226

2346

2227

2347

if (!elt->visible)

2228

2348

return NULL;

2233

2353

{

2234

2354

int i = 0, index = 0;

2235

2355

2236

while (&g_array_index (level->array, FilterElt, i) != elt)

2356

while (i < elt_index)

2237

2357

{

2238

2358

if (g_array_index (level->array, FilterElt, i).visible)

2239

2359

index++;

2243

2363

}

2244

2364

2245

2365

gtk_tree_path_prepend_index (retval, index);

2246

elt = level->parent_elt;

2366

elt_index = level->parent_elt_index;

2247

2367

level = level->parent_level;

2248

2368

}

2249

2369

2336

2456

int i = 0;

2337

2457

2338

2458

if (!filter->priv->root)

2339

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

2459

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

2340

2460

if (!filter->priv->root)

2341

2461

return FALSE;

2342

2462

2366

2486

else

2367

2487

{

2368

2488

int i = 0;

2369

2370

if (FILTER_ELT (parent->user_data2)->children == NULL)

2489

FilterElt *elt;

2490

2491

elt = FILTER_ELT (parent->user_data2);

2492

2493

if (elt->children == NULL)

2371

2494

gtk_tree_model_filter_build_level (filter,

2372

2495

FILTER_LEVEL (parent->user_data),

2373

FILTER_ELT (parent->user_data2),

2496

FILTER_LEVEL_ELT_INDEX (parent->user_data, elt),

2374

2497

FALSE);

2375

if (FILTER_ELT (parent->user_data2)->children == NULL)

2498

2499

if (elt->children == NULL)

2376

2500

return FALSE;

2377

2501

2378

if (FILTER_ELT (parent->user_data2)->children->visible_nodes <= 0)

2502

if (elt->children->visible_nodes <= 0)

2379

2503

return FALSE;

2380

2504

2381

2505

iter->stamp = filter->priv->stamp;

2382

iter->user_data = FILTER_ELT (parent->user_data2)->children;

2506

iter->user_data = elt->children;

2383

2507

2384

2508

level = FILTER_LEVEL (iter->user_data);

2385

2509

2429

2553

if (!elt->children

2430

2554

&& gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))

2431

2555

gtk_tree_model_filter_build_level (filter, FILTER_LEVEL (iter->user_data),

2432

elt, FALSE);

2556

FILTER_LEVEL_ELT_INDEX (iter->user_data, elt),

2557

FALSE);

2433

2558

2434

2559

if (elt->children && elt->children->visible_nodes > 0)

2435

2560

return TRUE;

2453

2578

if (!iter)

2454

2579

{

2455

2580

if (!filter->priv->root)

2456

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

2581

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

2457

2582

2458

2583

if (filter->priv->root)

2459

2584

return FILTER_LEVEL (filter->priv->root)->visible_nodes;

2472

2597

gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))

2473

2598

gtk_tree_model_filter_build_level (filter,

2474

2599

FILTER_LEVEL (iter->user_data),

2475

elt, FALSE);

2600

FILTER_LEVEL_ELT_INDEX (iter->user_data, elt),

2601

FALSE);

2476

2602

2477

2603

if (elt->children)

2478

2604

return elt->children->visible_nodes;

2538

2664

{

2539

2665

iter->stamp = GTK_TREE_MODEL_FILTER (model)->priv->stamp;

2540

2666

iter->user_data = level->parent_level;

2541

iter->user_data2 = level->parent_elt;

2667

iter->user_data2 = FILTER_LEVEL_PARENT_ELT (level);

2542

2668

2543

2669

return TRUE;

2544

2670

}

2571

2697

if (level->ref_count == 1)

2572

2698

{

2573

2699

FilterLevel *parent_level = level->parent_level;

2574

FilterElt *parent_elt = level->parent_elt;

2700

gint parent_elt_index = level->parent_elt_index;

2575

2701

2576

2702

/* we were at zero -- time to decrease the zero_ref_count val */

2577

2703

while (parent_level)

2578

2704

{

2579

parent_elt->zero_ref_count--;

2705

g_array_index (parent_level->array, FilterElt, parent_elt_index).zero_ref_count--;

2580

2706

2581

parent_elt = parent_level->parent_elt;

2707

parent_elt_index = parent_level->parent_elt_index;

2582

2708

parent_level = parent_level->parent_level;

2583

2709

}

2584

2710

2624

2750

if (level->ref_count == 0)

2625

2751

{

2626

2752

FilterLevel *parent_level = level->parent_level;

2627

FilterElt *parent_elt = level->parent_elt;

2753

gint parent_elt_index = level->parent_elt_index;

2628

2754

2629

2755

/* we are at zero -- time to increase the zero_ref_count val */

2630

2756

while (parent_level)

2631

2757

{

2632

parent_elt->zero_ref_count++;

2758

g_array_index (parent_level->array, FilterElt, parent_elt_index).zero_ref_count++;

2633

2759

2634

parent_elt = parent_level->parent_elt;

2760

parent_elt_index = parent_level->parent_elt_index;

2635

2761

parent_level = parent_level->parent_level;

2636

2762

}

2637

2763

3126

3252

child_indices = gtk_tree_path_get_indices (real_path);

3127

3253

3128

3254

if (filter->priv->root == NULL && build_levels)

3129

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

3255

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

3130

3256

level = FILTER_LEVEL (filter->priv->root);

3131

3257

3132

3258

for (i = 0; i < gtk_tree_path_get_depth (real_path); i++)

3146

3272

{

3147

3273

gtk_tree_path_append_index (retval, j);

3148

3274

if (!tmp->children && build_levels)

3149

gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);

3275

gtk_tree_model_filter_build_level (filter, level,

3276

FILTER_LEVEL_ELT_INDEX (level, tmp),

3277

FALSE);

3150

3278

level = tmp->children;

3151

3279

found_child = TRUE;

3152

3280

}

3168

3296

3169

3297

gtk_tree_path_append_index (retval, j);

3170

3298

if (!tmp->children && build_levels)

3171

gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);

3299

gtk_tree_model_filter_build_level (filter, level,

3300

FILTER_LEVEL_ELT_INDEX (level, tmp),

3301

FALSE);

3172

3302

level = tmp->children;

3173

3303

found_child = TRUE;

3174

3304

}

3260

3390

retval = gtk_tree_path_new ();

3261

3391

filter_indices = gtk_tree_path_get_indices (filter_path);

3262

3392

if (!filter->priv->root)

3263

gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);

3393

gtk_tree_model_filter_build_level (filter, NULL, -1, FALSE);

3264

3394

level = FILTER_LEVEL (filter->priv->root);

3265

3395

3266

3396

for (i = 0; i < gtk_tree_path_get_depth (filter_path); i++)

3277

3407

filter_indices[i]);

3278

3408

3279

3409

if (elt->children == NULL)

3280

gtk_tree_model_filter_build_level (filter, level, elt, FALSE);

3410

gtk_tree_model_filter_build_level (filter, level,

3411

FILTER_LEVEL_ELT_INDEX (level, elt),

3412

FALSE);

3281

3413

3282

3414

if (!level || level->visible_nodes <= filter_indices[i])

3283

3415

{

Older »