← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libinfinity/utopic-proposed

« back to all changes in this revision

Viewing changes to libinfgtk/inf-gtk-browser-view.c

  • Committer: Bazaar Package Importer
  • Author(s): Philipp Kern
  • Date: 2011-04-01 10:44:57 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20110401104457-q7927ly61fr51tqs
Tags: 0.5.0-1
* New upstream release.
* Drop patches applied upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libinfgtk/inf-gtk-browser-view.c
1
1
/* libinfinity - a GObject-based infinote implementation
2
 
 * Copyright (C) 2007, 2008, 2009 Armin Burgmeier <armin@arbur.net>
 
2
 * Copyright (C) 2007-2011 Armin Burgmeier <armin@arbur.net>
3
3
 *
4
4
 * This library is free software; you can redistribute it and/or
5
5
 * modify it under the terms of the GNU Lesser General Public
23
23
#include <libinfinity/inf-i18n.h>
24
24
#include <libinfinity/inf-signals.h>
25
25
 
26
 
#include <gtk/gtktreeview.h>
27
 
#include <gtk/gtktreeviewcolumn.h>
28
 
#include <gtk/gtktreeselection.h>
29
 
#include <gtk/gtkcellrendererpixbuf.h>
30
 
#include <gtk/gtkcellrenderertext.h>
31
 
#include <gtk/gtkcellrendererprogress.h>
32
 
#include <gtk/gtkimagemenuitem.h>
33
 
#include <gtk/gtkstock.h>
34
 
 
 
26
#include <gtk/gtk.h>
35
27
#include <gdk/gdkkeysyms.h>
36
28
 
37
29
#define INF_GTK_BROWSER_VIEW_INITIAL_EXPANSION \
70
62
 
71
63
typedef struct _InfGtkBrowserViewPrivate InfGtkBrowserViewPrivate;
72
64
struct _InfGtkBrowserViewPrivate {
73
 
  GtkWidget* treeview;
74
65
  GtkTreeViewColumn* column;
75
66
 
76
67
  /* Note that progress and status_text are never visible at the same time */
217
208
   * in the GTK+ treeview and friends. */
218
209
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
219
210
 
220
 
  if(GTK_WIDGET_REALIZED(priv->treeview))
 
211
#if GTK_CHECK_VERSION(2,20,0)
 
212
  if(gtk_widget_get_realized(GTK_WIDGET(view)))
 
213
#else
 
214
  if(GTK_WIDGET_REALIZED(GTK_WIDGET(view)))
 
215
#endif
221
216
  {
222
217
    gtk_tree_view_get_cell_area(
223
 
      GTK_TREE_VIEW(priv->treeview),
 
218
      GTK_TREE_VIEW(view),
224
219
      path,
225
220
      priv->column,
226
221
      &cell_area
229
224
    if(cell_area.height != 0)
230
225
    {
231
226
      gtk_widget_queue_draw_area(
232
 
        INF_GTK_BROWSER_VIEW_PRIVATE(view)->treeview,
 
227
        GTK_WIDGET(view),
233
228
        cell_area.x,
234
229
        cell_area.y,
235
230
        cell_area.width,
253
248
  path = gtk_tree_row_reference_get_path(reference);
254
249
  g_assert(path != NULL);
255
250
 
256
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
251
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
257
252
  gtk_tree_model_get_iter(model, &iter, path);
258
253
  inf_gtk_browser_view_redraw_row(view, path, &iter);
259
254
  gtk_tree_path_free(path);
335
330
                                                 gpointer user_data)
336
331
{
337
332
  InfGtkBrowserViewExplore* explore;
338
 
  InfGtkBrowserViewPrivate* priv;
 
333
  InfGtkBrowserView* view;
339
334
  GtkTreeModel* model;
340
335
  GtkTreePath* path;
341
336
  GtkTreeIter iter;
342
337
  gpointer initial_expansion;
343
338
 
344
339
  explore = (InfGtkBrowserViewExplore*)user_data;
345
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(explore->view_browser->view);
346
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
340
  view = explore->view_browser->view;
 
341
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
347
342
 
348
343
  path = gtk_tree_row_reference_get_path(explore->reference);
349
344
  g_assert(path != NULL);
350
345
 
351
346
  gtk_tree_model_get_iter(model, &iter, path);
352
 
  inf_gtk_browser_view_redraw_row(explore->view_browser->view, path, &iter);
 
347
  inf_gtk_browser_view_redraw_row(view, path, &iter);
353
348
 
354
349
  initial_expansion = g_object_get_data(
355
350
      G_OBJECT(explore->request),
365
360
   * any children. If we don't have any, then we can't expand of course. The
366
361
   * extra g_object_set_data does not need to be undone since the request
367
362
   * most likely vanishes anyway after exploration. */
368
 
  if(initial_expansion == explore->view_browser->view &&
 
363
  if(initial_expansion == view &&
369
364
     gtk_tree_model_iter_has_child(model, &iter))
370
365
  {
371
366
    g_object_set_data(
374
369
      NULL
375
370
    );
376
371
 
377
 
    gtk_tree_view_expand_row(GTK_TREE_VIEW(priv->treeview), path, FALSE);
 
372
    gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path, FALSE);
378
373
  }
379
374
 
380
375
  gtk_tree_path_free(path);
427
422
 
428
423
  sync->reference = gtk_tree_row_reference_new_proxy(
429
424
    G_OBJECT(priv->column),
430
 
    gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview)),
 
425
    gtk_tree_view_get_model(GTK_TREE_VIEW(view)),
431
426
    path
432
427
  );
433
428
 
475
470
  path = gtk_tree_row_reference_get_path(sync->reference);
476
471
  if(path != NULL)
477
472
  {
478
 
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
473
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
479
474
    gtk_tree_model_get_iter(model, &iter, path);
480
475
    inf_gtk_browser_view_redraw_row(view, path, &iter);
481
476
    gtk_tree_path_free(path);
533
528
 
534
529
  explore->reference = gtk_tree_row_reference_new_proxy(
535
530
    G_OBJECT(priv->column),
536
 
    gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview)),
 
531
    gtk_tree_view_get_model(GTK_TREE_VIEW(view)),
537
532
    path
538
533
  );
539
534
 
582
577
  path = gtk_tree_row_reference_get_path(expl->reference);
583
578
  if(path != NULL)
584
579
  {
585
 
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
580
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
586
581
    gtk_tree_model_get_iter(model, &iter, path);
587
582
    inf_gtk_browser_view_redraw_row(view, path, &iter);
588
583
    gtk_tree_path_free(path);
625
620
                                      gpointer user_data)
626
621
{
627
622
  InfGtkBrowserViewBrowser* view_browser;
628
 
  InfGtkBrowserViewPrivate* priv;
 
623
  InfGtkBrowserView* view;
629
624
  GtkTreeModel* model;
630
625
  GtkTreeIter tree_iter;
631
626
  GtkTreePath* path;
632
627
  gboolean result;
633
628
 
634
629
  view_browser = (InfGtkBrowserViewBrowser*)user_data;
635
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view_browser->view);
636
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
630
  view = view_browser->view;
 
631
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
637
632
 
638
633
  result = inf_gtk_browser_model_browser_iter_to_tree_iter(
639
634
    INF_GTK_BROWSER_MODEL(model),
650
645
  {
651
646
    path = gtk_tree_model_get_path(model, &tree_iter);
652
647
    inf_gtk_browser_view_explore_added(
653
 
      view_browser->view,
 
648
      view,
654
649
      browser,
655
650
      request,
656
651
      path,
667
662
                                          gpointer user_data)
668
663
{
669
664
  InfGtkBrowserViewBrowser* view_browser;
670
 
  InfGtkBrowserViewPrivate* priv;
 
665
  InfGtkBrowserView* view;
671
666
  InfSession* session;
672
667
  GtkTreeModel* model;
673
668
  GtkTreeIter tree_iter;
675
670
  gboolean result;
676
671
 
677
672
  view_browser = (InfGtkBrowserViewBrowser*)user_data;
678
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view_browser->view);
679
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
673
  view = view_browser->view;
 
674
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
680
675
 
681
676
  session = infc_session_proxy_get_session(proxy);
682
677
 
700
695
    {
701
696
      path = gtk_tree_model_get_path(model, &tree_iter);
702
697
      inf_gtk_browser_view_sync_added(
703
 
        view_browser->view,
 
698
        view,
704
699
        browser,
705
700
        proxy,
706
701
        path,
756
751
    request = infc_browser_iter_get_explore_request(browser, iter);
757
752
    if(request != NULL)
758
753
    {
759
 
      model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
754
      model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
760
755
 
761
756
      result = inf_gtk_browser_model_browser_iter_to_tree_iter(
762
757
        INF_GTK_BROWSER_MODEL(model),
795
790
      if(inf_session_get_synchronization_status(session, connection) !=
796
791
         INF_SESSION_SYNC_NONE)
797
792
      {
798
 
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
793
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
799
794
 
800
795
        result = inf_gtk_browser_model_browser_iter_to_tree_iter(
801
796
          INF_GTK_BROWSER_MODEL(model),
836
831
  InfcBrowserIter* browser_iter;
837
832
 
838
833
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
839
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
834
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
840
835
 
841
836
  gtk_tree_model_get(
842
837
    model,
888
883
      if(view_browser->initial_root_expansion == TRUE)
889
884
      {
890
885
        /*printf("Direct expansion for view %p\n", view);*/
891
 
        gtk_tree_view_expand_row(GTK_TREE_VIEW(priv->treeview), path, FALSE);
 
886
        gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path, FALSE);
892
887
 
893
888
        /* Handled expansion flag, so unset, could otherwise lead to another
894
889
         * try of expanding the root node. */
910
905
  InfGtkBrowserViewPrivate* priv;
911
906
  InfGtkBrowserViewBrowser* view_browser;
912
907
  GtkTreeModel* model;
913
 
  InfXmlConnection* connection;
914
 
  InfXmlConnectionStatus status;
915
908
  InfcBrowserIter* browser_iter;
916
909
  InfDiscoveryInfo* info;
917
910
 
918
911
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
919
 
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
912
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
920
913
 
921
914
  view_browser = g_slice_new(InfGtkBrowserViewBrowser);
922
915
  view_browser->view = view;
969
962
    priv->info_resolvs = g_slist_remove(priv->info_resolvs, info);
970
963
  }
971
964
 
972
 
  connection = infc_browser_get_connection(browser);
973
 
  g_object_get(G_OBJECT(connection), "status", &status, NULL);
 
965
  /*connection = infc_browser_get_connection(browser);
 
966
  g_object_get(G_OBJECT(connection), "status", &status, NULL);*/
974
967
 
975
968
  /* Initial explore if connection is already open */
976
 
  if(status == INF_XML_CONNECTION_OPEN)
 
969
  if(infc_browser_get_status(browser) == INFC_BROWSER_CONNECTED)
977
970
  {
978
971
    gtk_tree_model_get(
979
972
      model,
1093
1086
  InfGtkBrowserViewBrowser* view_browser;
1094
1087
  InfGtkBrowserViewExplore* explore;
1095
1088
  GtkTreePath* parent_path;
1096
 
  GtkTreeView* treeview;
1097
1089
 
1098
1090
  InfcSessionProxy* proxy;
1099
1091
  InfSession* session;
1127
1119
      {
1128
1120
        if(infc_browser_iter_get_explored(browser, browser_iter) == FALSE)
1129
1121
        {
1130
 
          treeview = GTK_TREE_VIEW(priv->treeview);
1131
 
 
1132
1122
          parent_path = gtk_tree_path_copy(path);
1133
1123
          gtk_tree_path_up(parent_path);
1134
1124
 
1135
 
          if(gtk_tree_view_row_expanded(treeview, parent_path))
 
1125
          if(gtk_tree_view_row_expanded(GTK_TREE_VIEW(view), parent_path))
1136
1126
            infc_browser_iter_explore(browser, browser_iter);
1137
1127
 
1138
1128
          gtk_tree_path_free(parent_path);
1325
1315
  GtkTreePath* path;
1326
1316
 
1327
1317
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
1328
 
  current_model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview));
 
1318
  current_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
1329
1319
 
1330
1320
  if(current_model != NULL)
1331
1321
  {
1374
1364
  }
1375
1365
 
1376
1366
  gtk_tree_view_set_model(
1377
 
    GTK_TREE_VIEW(priv->treeview),
 
1367
    GTK_TREE_VIEW(view),
1378
1368
    GTK_TREE_MODEL(model)
1379
1369
  );
1380
1370
 
1381
1371
  if(model != NULL)
1382
1372
  {
1383
1373
    gtk_tree_view_set_search_column(
1384
 
      GTK_TREE_VIEW(priv->treeview),
 
1374
      GTK_TREE_VIEW(view),
1385
1375
      INF_GTK_BROWSER_MODEL_COL_NAME
1386
1376
    );
1387
1377
 
1459
1449
 */
1460
1450
 
1461
1451
static void
1462
 
inf_gtk_browser_view_row_expanded_cb(GtkTreeView* tree_view,
1463
 
                                     GtkTreeIter* iter,
1464
 
                                     GtkTreePath* path,
1465
 
                                     gpointer user_data)
 
1452
inf_gtk_browser_view_row_expanded(GtkTreeView* tree_view,
 
1453
                                  GtkTreeIter* iter,
 
1454
                                  GtkTreePath* path)
1466
1455
{
1467
1456
  GtkTreeModel* model;
1468
1457
  InfcBrowser* browser;
1496
1485
 
1497
1486
  infc_browser_iter_free(browser_iter);
1498
1487
  g_object_unref(G_OBJECT(browser));
 
1488
 
 
1489
  if(GTK_TREE_VIEW_CLASS(parent_class)->row_expanded != NULL)
 
1490
    GTK_TREE_VIEW_CLASS(parent_class)->row_expanded(tree_view, iter, path);
1499
1491
}
1500
1492
 
1501
1493
static void
1502
 
inf_gtk_browser_view_row_activated_cb(GtkTreeView* tree_view,
1503
 
                                      GtkTreePath* path,
1504
 
                                      GtkTreeViewColumn* column,
1505
 
                                      gpointer user_data)
 
1494
inf_gtk_browser_view_row_activated(GtkTreeView* tree_view,
 
1495
                                   GtkTreePath* path,
 
1496
                                   GtkTreeViewColumn* column)
1506
1497
{
1507
1498
  InfGtkBrowserView* view;
1508
1499
  InfGtkBrowserViewPrivate* priv;
1519
1510
  GError* error;
1520
1511
  InfGtkBrowserViewBrowser* view_browser;
1521
1512
 
1522
 
  view = INF_GTK_BROWSER_VIEW(user_data);
 
1513
  view = INF_GTK_BROWSER_VIEW(tree_view);
1523
1514
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
1524
1515
 
1525
1516
  /* Connect to host, if not already */
1622
1613
    infc_browser_iter_free(browser_iter);
1623
1614
    g_object_unref(G_OBJECT(browser));
1624
1615
  }
 
1616
 
 
1617
  if(GTK_TREE_VIEW_CLASS(parent_class)->row_activated != NULL)
 
1618
    GTK_TREE_VIEW_CLASS(parent_class)->row_activated(tree_view, path, column);
1625
1619
}
1626
1620
 
1627
1621
static void
1677
1671
 
1678
1672
  /* Place menu below currently selected row */
1679
1673
 
1680
 
  bin_window = gtk_tree_view_get_bin_window(GTK_TREE_VIEW(priv->treeview));
 
1674
  bin_window = gtk_tree_view_get_bin_window(GTK_TREE_VIEW(view));
1681
1675
  gdk_window_get_origin(bin_window, &orig_x, &orig_y);
1682
1676
 
1683
1677
  screen = gtk_widget_get_screen(GTK_WIDGET(view));
1687
1681
 
1688
1682
  gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor);
1689
1683
  gtk_widget_size_request(GTK_WIDGET(menu), &menu_req);
1690
 
  gdk_drawable_get_size(GDK_DRAWABLE(bin_window), NULL, &height);
1691
 
 
1692
 
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
 
1684
 
 
1685
#if GTK_CHECK_VERSION(2, 91, 0)
 
1686
      height = gdk_window_get_height(bin_window);
 
1687
#else
 
1688
      gdk_drawable_get_size(GDK_DRAWABLE(bin_window), NULL, &height);
 
1689
#endif
 
1690
 
 
1691
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
1693
1692
  gtk_tree_selection_get_selected(selection, &model, &selected_iter);
1694
1693
  selected_path = gtk_tree_model_get_path(model, &selected_iter);
1695
1694
  gtk_tree_view_get_cell_area(
1696
 
    GTK_TREE_VIEW(priv->treeview),
 
1695
    GTK_TREE_VIEW(view),
1697
1696
    selected_path,
1698
1697
    priv->column,
1699
1698
    &cell_area
1779
1778
}
1780
1779
 
1781
1780
static gboolean
1782
 
inf_gtk_browser_view_button_press_event_cb(GtkTreeView* treeview,
1783
 
                                           GdkEventButton* event,
1784
 
                                           gpointer user_data)
 
1781
inf_gtk_browser_view_button_press_event(GtkWidget* treeview,
 
1782
                                        GdkEventButton* event)
1785
1783
{
1786
1784
  GtkTreePath* path;
1787
1785
  gboolean has_path;
1788
1786
 
1789
1787
  if(event->button == 3 &&
1790
 
     event->window == gtk_tree_view_get_bin_window(treeview))
 
1788
     event->window == gtk_tree_view_get_bin_window(GTK_TREE_VIEW(treeview)))
1791
1789
  {
1792
1790
    has_path = gtk_tree_view_get_path_at_pos(
1793
 
      treeview,
 
1791
      GTK_TREE_VIEW(treeview),
1794
1792
      event->x,
1795
1793
      event->y,
1796
1794
      &path,
1802
1800
    if(has_path)
1803
1801
    {
1804
1802
      gtk_tree_selection_select_path(
1805
 
        gtk_tree_view_get_selection(treeview),
 
1803
        gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
1806
1804
        path
1807
1805
      );
1808
1806
 
1809
1807
      gtk_tree_path_free(path);
1810
1808
 
1811
1809
      return inf_gtk_browser_view_show_popup(
1812
 
        INF_GTK_BROWSER_VIEW(user_data),
 
1810
        INF_GTK_BROWSER_VIEW(treeview),
1813
1811
        event->button,
1814
1812
        event->time
1815
1813
      );
1816
1814
    }
1817
1815
  }
1818
1816
 
1819
 
  return FALSE;
 
1817
  return GTK_WIDGET_CLASS(parent_class)->button_press_event(treeview, event);
1820
1818
}
1821
1819
 
1822
1820
static gboolean
1823
 
inf_gtk_browser_view_key_press_event_cb(GtkTreeView* treeview,
1824
 
                                        GdkEventKey* event,
1825
 
                                        gpointer user_data)
 
1821
inf_gtk_browser_view_key_press_event(GtkWidget* treeview,
 
1822
                                     GdkEventKey* event)
1826
1823
{
1827
1824
  GtkTreeSelection* selection;
1828
1825
  GtkTreeIter iter;
1829
1826
 
 
1827
#if GTK_CHECK_VERSION(2,90,7)
 
1828
  if(event->keyval == GDK_KEY_Menu)
 
1829
#else
1830
1830
  if(event->keyval == GDK_Menu)
 
1831
#endif
1831
1832
  {
1832
 
    selection = gtk_tree_view_get_selection(treeview);
 
1833
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
1833
1834
    if(gtk_tree_selection_get_selected(selection, NULL, &iter))
1834
1835
    {
1835
1836
      return inf_gtk_browser_view_show_popup(
1836
 
        INF_GTK_BROWSER_VIEW(user_data),
 
1837
        INF_GTK_BROWSER_VIEW(treeview),
1837
1838
        0,
1838
1839
        event->time
1839
1840
      );
1840
1841
    }
1841
1842
  }
1842
1843
 
1843
 
  return FALSE;
 
1844
  return GTK_WIDGET_CLASS(parent_class)->key_press_event(treeview, event);
1844
1845
}
1845
1846
 
1846
1847
/*
2242
2243
  view = INF_GTK_BROWSER_VIEW(instance);
2243
2244
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2244
2245
 
2245
 
  priv->treeview = gtk_tree_view_new();
2246
2246
  priv->column = gtk_tree_view_column_new();
2247
 
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
 
2247
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
2248
2248
  
2249
2249
  priv->renderer_icon = gtk_cell_renderer_pixbuf_new();
2250
2250
  priv->renderer_status_icon = gtk_cell_renderer_pixbuf_new();
2316
2316
  );
2317
2317
 
2318
2318
  g_signal_connect(
2319
 
    G_OBJECT(priv->treeview),
2320
 
    "row-expanded",
2321
 
    G_CALLBACK(inf_gtk_browser_view_row_expanded_cb),
2322
 
    view
2323
 
  );
2324
 
 
2325
 
  g_signal_connect(
2326
 
    G_OBJECT(priv->treeview),
2327
 
    "row-activated",
2328
 
    G_CALLBACK(inf_gtk_browser_view_row_activated_cb),
2329
 
    view
2330
 
  );
2331
 
 
2332
 
  g_signal_connect(
2333
 
    priv->treeview,
2334
 
    "button-press-event",
2335
 
    G_CALLBACK(inf_gtk_browser_view_button_press_event_cb),
2336
 
    view
2337
 
  );
2338
 
 
2339
 
  g_signal_connect(
2340
 
    priv->treeview,
2341
 
    "key-press-event",
2342
 
    G_CALLBACK(inf_gtk_browser_view_key_press_event_cb),
2343
 
    view
2344
 
  );
2345
 
 
2346
 
  g_signal_connect(
2347
2319
    selection,
2348
2320
    "changed",
2349
2321
    G_CALLBACK(inf_gtk_browser_view_selection_changed_cb),
2350
2322
    view
2351
2323
  );
2352
2324
 
2353
 
  gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview), priv->column);
2354
 
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(priv->treeview), FALSE);
2355
 
  gtk_container_add(GTK_CONTAINER(view), priv->treeview);
2356
 
  gtk_widget_show(priv->treeview);
 
2325
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), priv->column);
 
2326
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
2357
2327
}
2358
2328
 
2359
2329
static void
2365
2335
  view = INF_GTK_BROWSER_VIEW(object);
2366
2336
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2367
2337
 
2368
 
  if(priv->treeview != NULL)
2369
 
  {
2370
 
    /* This also resets all the browsers */
2371
 
    inf_gtk_browser_view_set_model(view, NULL);
2372
 
    priv->treeview = NULL;
2373
 
  }
 
2338
  inf_gtk_browser_view_set_model(view, NULL);
2374
2339
 
2375
2340
  G_OBJECT_CLASS(parent_class)->dispose(object);
2376
2341
}
2396
2361
                                  GParamSpec* pspec)
2397
2362
{
2398
2363
  InfGtkBrowserView* view;
2399
 
  InfGtkBrowserViewPrivate* priv;
2400
2364
 
2401
2365
  view = INF_GTK_BROWSER_VIEW(object);
2402
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2403
2366
 
2404
2367
  switch(prop_id)
2405
2368
  {
2406
2369
  case PROP_MODEL:
 
2370
 
 
2371
    if (g_value_get_object(value) != NULL)
 
2372
      g_assert(INF_GTK_IS_BROWSER_MODEL(g_value_get_object(value)));
 
2373
 
2407
2374
    inf_gtk_browser_view_set_model(
2408
2375
      view,
2409
2376
      INF_GTK_BROWSER_MODEL(g_value_get_object(value))
2410
2377
    );
2411
 
  
2412
2378
    break;
2413
2379
  default:
2414
2380
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
2423
2389
                                  GParamSpec* pspec)
2424
2390
{
2425
2391
  InfGtkBrowserView* view;
2426
 
  InfGtkBrowserViewPrivate* priv;
2427
2392
 
2428
2393
  view = INF_GTK_BROWSER_VIEW(object);
2429
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2430
2394
 
2431
2395
  switch(prop_id)
2432
2396
  {
2433
2397
  case PROP_MODEL:
2434
2398
    g_value_set_object(
2435
2399
      value,
2436
 
      G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview)))
 
2400
      G_OBJECT(gtk_tree_view_get_model(GTK_TREE_VIEW(view)))
2437
2401
    );
2438
2402
 
2439
2403
    break;
2447
2411
 * GtkObject / GtkWidget overrides */
2448
2412
 
2449
2413
static void
 
2414
#if GTK_CHECK_VERSION(2, 91, 0)
 
2415
inf_gtk_browser_view_destroy(GtkWidget* object)
 
2416
#else
2450
2417
inf_gtk_browser_view_destroy(GtkObject* object)
 
2418
#endif
2451
2419
{
2452
2420
  InfGtkBrowserView* view;
2453
2421
  InfGtkBrowserViewPrivate* priv;
2455
2423
  view = INF_GTK_BROWSER_VIEW(object);
2456
2424
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2457
2425
 
2458
 
  if(priv->treeview != NULL)
2459
 
  {
2460
 
    /* Unset model while treeview is alive */
2461
 
    inf_gtk_browser_view_set_model(view, NULL);
2462
 
    priv->treeview = NULL;
2463
 
  }
 
2426
  inf_gtk_browser_view_set_model(view, NULL);
2464
2427
 
 
2428
#if GTK_CHECK_VERSION(2, 91, 0)
 
2429
  if(GTK_WIDGET_CLASS(parent_class)->destroy)
 
2430
    GTK_WIDGET_CLASS(parent_class)->destroy(object);
 
2431
#else
2465
2432
  if(GTK_OBJECT_CLASS(parent_class)->destroy)
2466
2433
    GTK_OBJECT_CLASS(parent_class)->destroy(object);
2467
 
}
2468
 
 
2469
 
static void
2470
 
inf_gtk_browser_view_size_request(GtkWidget* widget,
2471
 
                                  GtkRequisition* requisition)
2472
 
{
2473
 
  InfGtkBrowserViewPrivate* priv;
2474
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(widget);
2475
 
 
2476
 
  if(priv->treeview != NULL)
2477
 
  {
2478
 
    gtk_widget_size_request(priv->treeview, requisition);
2479
 
  }
2480
 
  else
2481
 
  {
2482
 
    requisition->width = 0;
2483
 
    requisition->height = 0;
2484
 
  }
2485
 
}
2486
 
 
2487
 
static void
2488
 
inf_gtk_browser_view_size_allocate(GtkWidget* widget,
2489
 
                                   GtkAllocation* allocation)
2490
 
{
2491
 
  InfGtkBrowserViewPrivate* priv;
2492
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(widget);
2493
 
 
2494
 
  if(priv->treeview != NULL)
2495
 
  {
2496
 
    gtk_widget_size_allocate(priv->treeview, allocation);
2497
 
  }
2498
 
  else
2499
 
  {
2500
 
    allocation->x = 0;
2501
 
    allocation->y = 0;
2502
 
    allocation->width = 0;
2503
 
    allocation->height = 0;
2504
 
  }
2505
 
}
2506
 
 
2507
 
static void
2508
 
inf_gtk_browser_view_set_scroll_adjustments(InfGtkBrowserView* view,
2509
 
                                            GtkAdjustment* hadj,
2510
 
                                            GtkAdjustment* vadj)
2511
 
{
2512
 
  InfGtkBrowserViewPrivate* priv;
2513
 
  GtkWidgetClass* klass;
2514
 
 
2515
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2516
 
 
2517
 
  if(priv->treeview != NULL)
2518
 
  {
2519
 
    klass = GTK_WIDGET_GET_CLASS(priv->treeview);
2520
 
 
2521
 
    /* Delegate to TreeView */
2522
 
    g_assert(klass->set_scroll_adjustments_signal);
2523
 
    g_signal_emit(
2524
 
      G_OBJECT(priv->treeview),
2525
 
      klass->set_scroll_adjustments_signal,
2526
 
      0,
2527
 
      hadj,
2528
 
      vadj
2529
 
    );
2530
 
  }
 
2434
#endif
2531
2435
}
2532
2436
 
2533
2437
/*
2539
2443
                                gpointer class_data)
2540
2444
{
2541
2445
  GObjectClass* object_class;
2542
 
  GtkObjectClass* gtk_object_class;
2543
2446
  GtkWidgetClass* widget_class;
2544
2447
  InfGtkBrowserViewClass* view_class;
 
2448
  GtkTreeViewClass* tree_class;
 
2449
#if ! GTK_CHECK_VERSION(2, 91, 0)
 
2450
  GtkObjectClass *gtk_object_class;
 
2451
#endif
2545
2452
 
2546
2453
  object_class = G_OBJECT_CLASS(g_class);
2547
 
  gtk_object_class = GTK_OBJECT_CLASS(g_class);
2548
2454
  widget_class = GTK_WIDGET_CLASS(g_class);
2549
2455
  view_class = INF_GTK_BROWSER_VIEW_CLASS(g_class);
 
2456
  tree_class = GTK_TREE_VIEW_CLASS(g_class);
 
2457
 
 
2458
#if ! GTK_CHECK_VERSION(2, 91, 0)
 
2459
  gtk_object_class = GTK_OBJECT_CLASS(g_class);
 
2460
  gtk_object_class->destroy = inf_gtk_browser_view_destroy;
 
2461
#else
 
2462
  widget_class->destroy = inf_gtk_browser_view_destroy;
 
2463
#endif
2550
2464
 
2551
2465
  parent_class = G_OBJECT_CLASS(g_type_class_peek_parent(g_class));
2552
2466
  g_type_class_add_private(g_class, sizeof(InfGtkBrowserViewPrivate));
2555
2469
  object_class->finalize = inf_gtk_browser_view_finalize;
2556
2470
  object_class->set_property = inf_gtk_browser_view_set_property;
2557
2471
  object_class->get_property = inf_gtk_browser_view_get_property;
2558
 
  gtk_object_class->destroy = inf_gtk_browser_view_destroy;
2559
 
  widget_class->size_request = inf_gtk_browser_view_size_request;
2560
 
  widget_class->size_allocate = inf_gtk_browser_view_size_allocate;
 
2472
 
 
2473
  tree_class->row_expanded = inf_gtk_browser_view_row_expanded;
 
2474
  tree_class->row_activated = inf_gtk_browser_view_row_activated;
 
2475
 
 
2476
  widget_class->button_press_event = inf_gtk_browser_view_button_press_event;
 
2477
  widget_class->key_press_event = inf_gtk_browser_view_key_press_event;
2561
2478
 
2562
2479
  view_class->activate = NULL;
2563
2480
  view_class->selection_changed = NULL;
2564
2481
  view_class->populate_popup = NULL;
2565
 
  view_class->set_scroll_adjustments =
2566
 
    inf_gtk_browser_view_set_scroll_adjustments;
2567
2482
 
2568
 
  g_object_class_install_property(
2569
 
    object_class,
2570
 
    PROP_MODEL,
2571
 
    g_param_spec_object(
2572
 
      "model",
2573
 
      "Model", 
2574
 
      "The model to display",
2575
 
      INF_GTK_TYPE_BROWSER_MODEL,
2576
 
      G_PARAM_READWRITE | G_PARAM_CONSTRUCT
2577
 
    )
2578
 
  );
 
2483
  g_object_class_override_property(object_class, PROP_MODEL, "model");
2579
2484
 
2580
2485
  view_signals[ACTIVATE] = g_signal_new(
2581
2486
    "activate",
2612
2517
    1,
2613
2518
    GTK_TYPE_MENU
2614
2519
  );
2615
 
 
2616
 
  widget_class->set_scroll_adjustments_signal = g_signal_new(
2617
 
    "set-scroll-adjustments",
2618
 
    G_TYPE_FROM_CLASS(object_class),
2619
 
    G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
2620
 
    G_STRUCT_OFFSET(InfGtkBrowserViewClass, set_scroll_adjustments),
2621
 
    NULL, NULL,
2622
 
    inf_marshal_VOID__OBJECT_OBJECT,
2623
 
    G_TYPE_NONE,
2624
 
    2,
2625
 
    GTK_TYPE_ADJUSTMENT,
2626
 
    GTK_TYPE_ADJUSTMENT
2627
 
  );
2628
2520
}
2629
2521
 
2630
2522
GType
2648
2540
    };
2649
2541
 
2650
2542
    browser_view_type = g_type_register_static(
2651
 
      GTK_TYPE_BIN,
 
2543
      GTK_TYPE_TREE_VIEW,
2652
2544
      "InfGtkBrowserView",
2653
2545
      &browser_view_type_info,
2654
2546
      0
2694
2586
}
2695
2587
 
2696
2588
/**
2697
 
 * inf_gtk_browser_view_get_model:
2698
 
 * @view: A #InfGtkBrowserView.
2699
 
 *
2700
 
 * Returns the model displayed by @view.
2701
 
 * 
2702
 
 * Returns: A #InfGtkBrowserModel.
2703
 
 **/
2704
 
InfGtkBrowserModel*
2705
 
inf_gtk_browser_view_get_model(InfGtkBrowserView* view)
2706
 
{
2707
 
  InfGtkBrowserViewPrivate* priv;
2708
 
  GtkTreeView* treeview;
2709
 
 
2710
 
  g_return_val_if_fail(INF_GTK_IS_BROWSER_VIEW(view), NULL);
2711
 
 
2712
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2713
 
  treeview = GTK_TREE_VIEW(priv->treeview);
2714
 
 
2715
 
  return INF_GTK_BROWSER_MODEL(gtk_tree_view_get_model(treeview));
2716
 
}
2717
 
 
2718
 
/**
2719
2589
 * inf_gtk_browser_view_get_selected:
2720
2590
 * @view: A #InfGtkBrowserView.
2721
2591
 * @iter: An uninitialized #GtkTreeIter.
2729
2599
inf_gtk_browser_view_get_selected(InfGtkBrowserView* view,
2730
2600
                                  GtkTreeIter* iter)
2731
2601
{
2732
 
  InfGtkBrowserViewPrivate* priv;
2733
 
  GtkTreeView* treeview;
2734
2602
  GtkTreeSelection* selection;
2735
2603
 
2736
2604
  g_return_val_if_fail(INF_GTK_IS_BROWSER_VIEW(view), FALSE);
2737
2605
 
2738
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2739
 
  treeview = GTK_TREE_VIEW(priv->treeview);
2740
 
  selection = gtk_tree_view_get_selection(treeview);
 
2606
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
2741
2607
  return gtk_tree_selection_get_selected(selection, NULL, iter);
2742
2608
}
2743
2609
 
2753
2619
inf_gtk_browser_view_set_selected(InfGtkBrowserView* view,
2754
2620
                                  GtkTreeIter* iter)
2755
2621
{
2756
 
  InfGtkBrowserViewPrivate* priv;
2757
 
  GtkTreeView* treeview;
2758
2622
  GtkTreeSelection* selection;
2759
2623
  GtkTreePath* path;
2760
2624
 
2761
2625
  g_return_if_fail(INF_GTK_IS_BROWSER_VIEW(view));
2762
2626
  g_return_if_fail(iter != NULL);
2763
2627
 
2764
 
  priv = INF_GTK_BROWSER_VIEW_PRIVATE(view);
2765
 
  treeview = GTK_TREE_VIEW(priv->treeview);
2766
 
  selection = gtk_tree_view_get_selection(treeview);
 
2628
  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
2767
2629
 
2768
2630
  path = gtk_tree_model_get_path(
2769
 
    gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview)),
 
2631
    gtk_tree_view_get_model(GTK_TREE_VIEW(view)),
2770
2632
    iter
2771
2633
  );
2772
2634
  g_assert(path != NULL);
2773
2635
 
2774
 
  gtk_tree_view_expand_to_path(treeview, path);
2775
 
  gtk_tree_view_scroll_to_cell(treeview, path, NULL, FALSE, 0.0f, 0.0f);
 
2636
  gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path);
 
2637
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view), path, NULL, FALSE, 0.0f, 0.0f);
2776
2638
  gtk_tree_path_free(path);
2777
2639
 
2778
2640
  gtk_tree_selection_select_iter(selection, iter);