freebsd-ports-gnome - FreeBSD GNOME current development ports (https://github.com/freebsd/freebsd-ports-gnome)

FreeBSD GNOME current development ports (https://github.com/freebsd/freebsd-ports-gnome)

about summary refs log tree commit diff stats

diff options

author	beat <beat@FreeBSD.org>	2010-07-25 16:08:24 +0800
committer	beat <beat@FreeBSD.org>	2010-07-25 16:08:24 +0800
commit	3f37ec9e555a1afba50447bf2262aaaef814d326 (patch)
tree	8650ab2632cf326d3928b9e44c9edb312226d261 /Mk/bsd.kde4.mk
parent	5678c2684983de0194b3fdd6842c7ad29233afea (diff)
download	freebsd-ports-gnome-3f37ec9e555a1afba50447bf2262aaaef814d326.tar.gz freebsd-ports-gnome-3f37ec9e555a1afba50447bf2262aaaef814d326.tar.zst freebsd-ports-gnome-3f37ec9e555a1afba50447bf2262aaaef814d326.zip

- Update to 3.6.8

Diffstat (limited to 'Mk/bsd.kde4.mk')

0 files changed, 0 insertions, 0 deletions

03-17 16:53:48 +0800 rename empathy-dispatcher to empathy-request-util' href='/~lantw44/cgit/gsoc2013-empathy/commit/src/empathy-main-window.c?id=23d90f884b28cabd3b9b986998c118314a9238f9'>23d90f884

692886962

8e7b3f45c

f014e7c05

8e7b3f45c

8e7b3f45c

750400297

d7e8bf5c3

750400297

7cd053aff

53ff0c11c

154251095

750400297

da3e82030

b3ee9d591

750400297

1
2

18
19

30
31

39
40

41
42

49
50
51

58
59

62
63

81
82

84
85
86

93
94
95

97
98

101
102

104
105

107
108

112
113

114
115

118
119
120

125
126
127

130
131

134
135

138
139

145
146

153
154

164
165

166
167

171
172
173

174
175
176

181
182
183

184
185
186

187
188
189

208
209

210
211
212

214
215

216
217
218

221
222
223

224
225

226
227
228

261
262

266
267

289
290
291

296
297
298

520
521

523
524

534
535

545
546

547
548

562
563

572
573

574
575

578
579

582
583

584
585

594
595

604
605

617
618

627
628

657
658

660
661

667
668

684
685
686

688
689

691
692

693
694

699
700
701

703
704

706
707

709
710
711

742
743

744
745

763
764

768
769

774
775
776

809
810

811
812

837
838
839

847
848

850
851

853
854

855
856
857

870
871

906
907

911
912

922
923

924
925

932
933

940
941
942

950
951

952
953
954

957
958

960
961

976
977
978

998
999

1007
1008

1013
1014
1015

1016
1017

1018
1019

1024
1025

1027
1028

1029
1030

1033
1034
1035

1046
1047

1048
1049

1062
1063

1099
1100

1102
1103

1155
1156

1157
1158

1160
1161
1162

1164
1165

1172
1173
1174

1177
1178

1181
1182
1183

1187
1188

1196
1197

1198
1199

1201
1202

1205
1206
1207

1209
1210

1212
1213

1214
1215

1219
1220
1221

1222
1223
1224

1243
1244

1246
1247

1249
1250
1251

1253
1254

1257
1258

1265
1266

1281
1282

1291
1292
1293

1298
1299
1300

1301
1302
1303

1305
1306
1307

1318
1319

1321
1322
1323

1325
1326

1328
1329
1330

1332
1333

1337
1338

1341
1342
1343

1347
1348
1349

1355
1356
1357

1359
1360

1383
1384
1385

1392
1393

1395
1396

1398
1399

1400
1401

1403
1404

1412
1413

1414
1415

1416
1417

1419
1420
1421

1429
1430

1431
1432

1433
1434
1435

1441
1442
1443

1445
1446

1454
1455

1456
1457

1459
1460

1462
1463
1464

1465
1466

1467
1468

1472
1473
1474

1488
1489

1490
1491
1492

1494
1495
1496

1506
1507
1508

1515
1516

1521
1522

1526
1527

1528
1529

1531
1532
1533

1535
1536
1537

1538
1539

1583
1584
1585

1592
1593
1594

1614
1615
1616

1623
1624
1625

1630
1631
1632

1645
1646
1647

1648
1649
1650

1651
1652

1659
1660

1669
1670

1671
1672
1673

1674
1675

1678
1679

1681
1682

1683
1684
1685

1686
1687

1693
1694

1695
1696
1697

1703
1704

1721
1722

1725
1726
1727

1731
1732

1736
1737

1743
1744
1745

1747
1748

1750
1751
1752

1754
1755

1757
1758

1764
1765
1766

1768
1769

1771
1772
1773

1781
1782

1784
1785

1791
1792

1794
1795

1797
1798

1799
1800

1802
1803

1809
1810

1812
1813

1815
1816

1817
1818

1821
1822
1823

1825
1826

1829
1830
1831

1833
1834

1836
1837
1838

1867
1868

1869
1870
1871

1872
1873
1874

1876
1877
1878

1880
1881

1883
1884
1885

1886
1887
1888

1890
1891
1892

1894
1895

1897
1898
1899

1901
1902

1912
1913
1914

1917
1918
1919

1927
1928
1929

1930
1931
1932

1933
1934
1935

1936
1937
1938

1939
1940
1941

1942
1943

1944
1945

1947
1948

1958
1959

1960
1961

1970
1971

1975
1976
1977

1983
1984

1988
1989

1992
1993
1994

2011
2012
2013

2014
2015
2016

2018
2019

2023
2024

2027
2028

2035
2036

2039
2040

2041
2042
2043

2053
2054

2055
2056
2057

2060
2061

2062
2063
2064

2103
2104

2105
2106

2110
2111

2113
2114

2116
2117

2118
2119
2120

2122
2123
2124

2139
2140

2141
2142

2146
2147

2149
2150
2151

2152
2153
2154

2156
2157

2172
2173

2179
2180

2182
2183

2190
2191

2209
2210

2214
2215

2217
2218

2220
2221
2222

2224
2225

2226
2227

2230
2231

2235
2236
2237

2238
2239

2240
2241

2246
2247
2248

2256
2257
2258

2259
2260

2261
2262
2263

2264
2265

2275
2276

2277
2278

2282
2283

2291
2292

2330
2331

2335
2336

2344
2345
2346

2352
2353
2354

2357
2358

2362
2363
2364

2367
2368

2372
2373
2374

2381
2382

2383
2384

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * Copyright (C) 2002-2007 Imendio AB
 * Copyright (C) 2007-2010 Collabora Ltd.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301  USA
 *
 * Authors: Xavier Claessens <xclaesse@gmail.com>
 *          Danielle Madeley <danielle.madeley@collabora.co.uk>
 */

#include <config.h>

#include <sys/stat.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <glib/gi18n.h>

#include <telepathy-glib/account-manager.h>
#include <telepathy-glib/util.h>
#include <folks/folks.h>

#include <libempathy/empathy-contact.h>
#include <libempathy/empathy-utils.h>
#include <libempathy/empathy-request-util.h>
#include <libempathy/empathy-chatroom-manager.h>
#include <libempathy/empathy-chatroom.h>
#include <libempathy/empathy-contact-list.h>
#include <libempathy/empathy-contact-manager.h>
#include <libempathy/empathy-gsettings.h>
#include <libempathy/empathy-individual-manager.h>
#include <libempathy/empathy-gsettings.h>
#include <libempathy/empathy-status-presets.h>
#include <libempathy/empathy-tp-contact-factory.h>

#include <libempathy-gtk/empathy-contact-dialogs.h>
#include <libempathy-gtk/empathy-contact-list-store.h>
#include <libempathy-gtk/empathy-contact-list-view.h>
#include <libempathy-gtk/empathy-live-search.h>
#include <libempathy-gtk/empathy-contact-blocking-dialog.h>
#include <libempathy-gtk/empathy-contact-search-dialog.h>
#include <libempathy-gtk/empathy-geometry.h>
#include <libempathy-gtk/empathy-gtk-enum-types.h>
#include <libempathy-gtk/empathy-individual-dialogs.h>
#include <libempathy-gtk/empathy-individual-store.h>
#include <libempathy-gtk/empathy-individual-view.h>
#include <libempathy-gtk/empathy-new-message-dialog.h>
#include <libempathy-gtk/empathy-new-call-dialog.h>
#include <libempathy-gtk/empathy-log-window.h>
#include <libempathy-gtk/empathy-presence-chooser.h>
#include <libempathy-gtk/empathy-sound-manager.h>
#include <libempathy-gtk/empathy-ui-utils.h>

#include "empathy-accounts-dialog.h"
#include "empathy-call-observer.h"
#include "empathy-chat-manager.h"
#include "empathy-main-window.h"
#include "empathy-preferences.h"
#include "empathy-about-dialog.h"
#include "empathy-debug-window.h"
#include "empathy-new-chatroom-dialog.h"
#include "empathy-map-view.h"
#include "empathy-chatrooms-window.h"
#include "empathy-event-manager.h"
#include "empathy-ft-manager.h"
#include "empathy-migrate-butterfly-logs.h"

#define DEBUG_FLAG EMPATHY_DEBUG_OTHER
#include <libempathy/empathy-debug.h>

/* Flashing delay for icons (milliseconds). */
#define FLASH_TIMEOUT 500

/* Minimum width of roster window if something goes wrong. */
#define MIN_WIDTH 50

/* Accels (menu shortcuts) can be configured and saved */
#define ACCELS_FILENAME "accels.txt"

/* Name in the geometry file */
#define GEOMETRY_NAME "main-window"

enum {
    PAGE_CONTACT_LIST = 0,
    PAGE_NO_MATCH
};

G_DEFINE_TYPE (EmpathyMainWindow, empathy_main_window, GTK_TYPE_WINDOW);

#define GET_PRIV(self) ((EmpathyMainWindowPriv *)((EmpathyMainWindow *) self)->priv)

struct _EmpathyMainWindowPriv {
    EmpathyContactList      *contact_manager;
    EmpathyIndividualStore  *individual_store;
    EmpathyIndividualView   *individual_view;
    TpAccountManager        *account_manager;
    EmpathyChatroomManager  *chatroom_manager;
    EmpathyEventManager     *event_manager;
    EmpathySoundManager     *sound_mgr;
    EmpathyCallObserver     *call_observer;
    guint                    flash_timeout_id;
    gboolean                 flash_on;
    gboolean                 empty;

    GSettings              *gsettings_ui;
    GSettings              *gsettings_contacts;

    GtkWidget              *preferences;
    GtkWidget              *main_vbox;
    GtkWidget              *throbber;
    GtkWidget              *throbber_tool_item;
    GtkWidget              *presence_toolbar;
    GtkWidget              *presence_chooser;
    GtkWidget              *errors_vbox;
    GtkWidget              *auth_vbox;
    GtkWidget              *search_bar;
    GtkWidget              *notebook;
    GtkWidget              *no_entry_label;

    GtkToggleAction        *show_protocols;
    GtkRadioAction         *sort_by_name;
    GtkRadioAction         *sort_by_status;
    GtkRadioAction         *normal_with_avatars;
    GtkRadioAction         *normal_size;
    GtkRadioAction         *compact_size;

    GtkUIManager           *ui_manager;
    GtkAction              *view_history;
    GtkAction              *room_join_favorites;
    GtkWidget              *room_menu;
    GtkWidget              *room_separator;
    GtkWidget              *edit_context;
    GtkWidget              *edit_context_separator;

    GtkActionGroup         *balance_action_group;
    GtkAction              *view_balance_show_in_roster;
    GtkWidget              *balance_vbox;

    guint                   size_timeout_id;

    /* reffed TpAccount* => visible GtkInfoBar* */
    GHashTable             *errors;

    /* EmpathyEvent* => visible GtkInfoBar* */
    GHashTable             *auths;

    /* stores a mapping from TpAccount to Handler ID to prevent
     * to listen more than once to the status-changed signal */
    GHashTable             *status_changed_handlers;

    /* Actions that are enabled when there are connected accounts */
    GList                  *actions_connected;

    /* The idle event source to migrate butterfly's logs */
    guint butterfly_log_migration_members_changed_id;
};

static void
main_window_flash_stop (EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);

    if (priv->flash_timeout_id == 0) {
        return;
    }

    DEBUG ("Stop flashing");
    g_source_remove (priv->flash_timeout_id);
    priv->flash_timeout_id = 0;
    priv->flash_on = FALSE;
}

typedef struct {
    EmpathyEvent       *event;
    gboolean            on;
    EmpathyMainWindow  *window;
} FlashForeachData;

static gboolean
main_window_flash_foreach (GtkTreeModel *model,
               GtkTreePath  *path,
               GtkTreeIter  *iter,
               gpointer      user_data)
{
    FlashForeachData *data = (FlashForeachData *) user_data;
    FolksIndividual *individual;
    EmpathyContact   *contact;
    const gchar      *icon_name;
    GtkTreePath      *parent_path = NULL;
    GtkTreeIter       parent_iter;
    GdkPixbuf        *pixbuf = NULL;

    gtk_tree_model_get (model, iter,
                EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL, &individual,
                -1);

    if (individual == NULL)
        return FALSE;

    contact = empathy_contact_dup_from_folks_individual (individual);
    if (contact != data->event->contact)
        goto out;

    if (data->on) {
        icon_name = data->event->icon_name;
        pixbuf = empathy_pixbuf_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
    } else {
        pixbuf = empathy_individual_store_get_individual_status_icon (
                        GET_PRIV (data->window)->individual_store,
                        individual);
        if (pixbuf != NULL)
            g_object_ref (pixbuf);
    }

    gtk_tree_store_set (GTK_TREE_STORE (model), iter,
                EMPATHY_INDIVIDUAL_STORE_COL_ICON_STATUS, pixbuf,
                -1);

    /* To make sure the parent is shown correctly, we emit
     * the row-changed signal on the parent so it prompts
     * it to be refreshed by the filter func.
     */
    if (gtk_tree_model_iter_parent (model, &parent_iter, iter)) {
        parent_path = gtk_tree_model_get_path (model, &parent_iter);
    }
    if (parent_path) {
        gtk_tree_model_row_changed (model, parent_path, &parent_iter);
        gtk_tree_path_free (parent_path);
    }

out:
    g_object_unref (individual);
    tp_clear_object (&contact);
    tp_clear_object (&pixbuf);

    return FALSE;
}

static gboolean
main_window_flash_cb (EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkTreeModel     *model;
    GSList           *events, *l;
    gboolean          found_event = FALSE;
    FlashForeachData  data;

    priv->flash_on = !priv->flash_on;
    data.on = priv->flash_on;
    model = GTK_TREE_MODEL (priv->individual_store);

    events = empathy_event_manager_get_events (priv->event_manager);
    for (l = events; l; l = l->next) {
        data.event = l->data;
        data.window = window;
        if (!data.event->contact || !data.event->must_ack) {
            continue;
        }

        found_event = TRUE;
        gtk_tree_model_foreach (model,
                    main_window_flash_foreach,
                    &data);
    }

    if (!found_event) {
        main_window_flash_stop (window);
    }

    return TRUE;
}

static void
main_window_flash_start (EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);

    if (priv->flash_timeout_id != 0) {
        return;
    }

    DEBUG ("Start flashing");
    priv->flash_timeout_id = g_timeout_add (FLASH_TIMEOUT,
                        (GSourceFunc) main_window_flash_cb,
                        window);
    main_window_flash_cb (window);
}

static void
main_window_remove_auth (EmpathyMainWindow *window,
             EmpathyEvent      *event)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkWidget *error_widget;

    error_widget = g_hash_table_lookup (priv->auths, event);
    if (error_widget != NULL) {
        gtk_widget_destroy (error_widget);
        g_hash_table_remove (priv->auths, event);
    }
}

static void
main_window_auth_add_clicked_cb (GtkButton         *button,
                 EmpathyMainWindow *window)
{
    EmpathyEvent *event;

    event = g_object_get_data (G_OBJECT (button), "event");

    empathy_event_approve (event);

    main_window_remove_auth (window, event);
}

static void
main_window_auth_close_clicked_cb (GtkButton         *button,
                   EmpathyMainWindow *window)
{
    EmpathyEvent *event;

    event = g_object_get_data (G_OBJECT (button), "event");

    empathy_event_decline (event);
    main_window_remove_auth (window, event);
}

static void
main_window_auth_display (EmpathyMainWindow *window,
              EmpathyEvent      *event)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    TpAccount *account = event->account;
    GtkWidget *info_bar;
    GtkWidget *content_area;
    GtkWidget *image;
    GtkWidget *label;
    GtkWidget *add_button;
    GtkWidget *close_button;
    GtkWidget *action_area;
    GtkWidget *action_table;
    const gchar *icon_name;
    gchar *str;

    if (g_hash_table_lookup (priv->auths, event) != NULL) {
        return;
    }

    info_bar = gtk_info_bar_new ();
    gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_QUESTION);

    gtk_widget_set_no_show_all (info_bar, TRUE);
    gtk_box_pack_start (GTK_BOX (priv->auth_vbox), info_bar, FALSE, TRUE, 0);
    gtk_widget_show (info_bar);

    icon_name = tp_account_get_icon_name (account);
    image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
    gtk_widget_show (image);

    str = g_markup_printf_escaped ("<b>%s</b>\n%s",
                       tp_account_get_display_name (account),
                       _("Password required"));

    label = gtk_label_new (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    gtk_widget_show (label);

    g_free (str);

    content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
    gtk_box_pack_start (GTK_BOX (content_area), image, FALSE, FALSE, 0);
    gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);

    image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON);
    add_button = gtk_button_new ();
    gtk_button_set_image (GTK_BUTTON (add_button), image);
    gtk_widget_set_tooltip_text (add_button, _("Provide Password"));
    gtk_widget_show (add_button);

    image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON);
    close_button = gtk_button_new ();
    gtk_button_set_image (GTK_BUTTON (close_button), image);
    gtk_widget_set_tooltip_text (close_button, _("Disconnect"));
    gtk_widget_show (close_button);

    action_table = gtk_table_new (1, 2, FALSE);
    gtk_table_set_col_spacings (GTK_TABLE (action_table), 6);
    gtk_widget_show (action_table);

    action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (info_bar));
    gtk_box_pack_start (GTK_BOX (action_area), action_table, FALSE, FALSE, 0);

    gtk_table_attach (GTK_TABLE (action_table), add_button, 0, 1, 0, 1,
              (GtkAttachOptions) (GTK_SHRINK),
              (GtkAttachOptions) (GTK_SHRINK), 0, 0);
    gtk_table_attach (GTK_TABLE (action_table), close_button, 1, 2, 0, 1,
              (GtkAttachOptions) (GTK_SHRINK),
              (GtkAttachOptions) (GTK_SHRINK), 0, 0);

    g_object_set_data_full (G_OBJECT (info_bar),
                "event", event, NULL);
    g_object_set_data_full (G_OBJECT (add_button),
                "event", event, NULL);
    g_object_set_data_full (G_OBJECT (close_button),
                "event", event, NULL);

    g_signal_connect (add_button, "clicked",
              G_CALLBACK (main_window_auth_add_clicked_cb),
              window);
    g_signal_connect (close_button, "clicked",
              G_CALLBACK (main_window_auth_close_clicked_cb),
              window);

    gtk_widget_show (priv->auth_vbox);

    g_hash_table_insert (priv->auths, event, info_bar);
}

static void
modify_event_count (GtkTreeModel *model,
            GtkTreeIter *iter,
            EmpathyEvent *event,
            gboolean increase)
{
    FolksIndividual *individual;
    EmpathyContact *contact;
    guint count;

    gtk_tree_model_get (model, iter,
                EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL, &individual,
                EMPATHY_INDIVIDUAL_STORE_COL_EVENT_COUNT, &count,
                -1);

    if (individual == NULL)
        return;

    increase ? count++ : count--;

    contact = empathy_contact_dup_from_folks_individual (individual);
    if (contact == event->contact) {
        gtk_tree_store_set (GTK_TREE_STORE (model), iter,
                    EMPATHY_INDIVIDUAL_STORE_COL_EVENT_COUNT, count, -1);
    }

    tp_clear_object (&contact);
    g_object_unref (individual);
}

static gboolean
increase_event_count_foreach (GtkTreeModel *model,
                  GtkTreePath *path,
                  GtkTreeIter *iter,
                  gpointer user_data)
{
    EmpathyEvent *event = user_data;

    modify_event_count (model, iter, event, TRUE);

    return FALSE;
}

static void
increase_event_count (EmpathyMainWindow *self,
              EmpathyEvent *event)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (self);
    GtkTreeModel *model;

    model = GTK_TREE_MODEL (priv->individual_store);

    gtk_tree_model_foreach (model, increase_event_count_foreach, event);
}

static gboolean
decrease_event_count_foreach (GtkTreeModel *model,
                  GtkTreePath *path,
                  GtkTreeIter *iter,
                  gpointer user_data)
{
    EmpathyEvent *event = user_data;

    modify_event_count (model, iter, event, FALSE);

    return FALSE;
}

static void
decrease_event_count (EmpathyMainWindow *self,
              EmpathyEvent *event)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (self);
    GtkTreeModel *model;

    model = GTK_TREE_MODEL (priv->individual_store);

    gtk_tree_model_foreach (model, decrease_event_count_foreach, event);
}

static void
main_window_event_added_cb (EmpathyEventManager *manager,
                EmpathyEvent        *event,
                EmpathyMainWindow   *window)
{
    if (event->contact) {
        increase_event_count (window, event);

        main_window_flash_start (window);
    } else if (event->type == EMPATHY_EVENT_TYPE_AUTH) {
        main_window_auth_display (window, event);
    }
}

static void
main_window_event_removed_cb (EmpathyEventManager *manager,
                  EmpathyEvent        *event,
                  EmpathyMainWindow   *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    FlashForeachData data;

    if (event->type == EMPATHY_EVENT_TYPE_AUTH) {
        main_window_remove_auth (window, event);
        return;
    }

    if (!event->contact) {
        return;
    }

    decrease_event_count (window, event);

    data.on = FALSE;
    data.event = event;
    data.window = window;
    gtk_tree_model_foreach (GTK_TREE_MODEL (priv->individual_store),
                main_window_flash_foreach,
                &data);
}

static void
main_window_row_activated_cb (EmpathyContactListView *view,
                  GtkTreePath            *path,
                  GtkTreeViewColumn      *col,
                  EmpathyMainWindow      *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    EmpathyContact *contact = NULL;
    FolksIndividual *individual;
    GtkTreeModel   *model;
    GtkTreeIter     iter;
    GSList         *events, *l;

    model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->individual_view));
    gtk_tree_model_get_iter (model, &iter, path);

    gtk_tree_model_get (model, &iter,
                EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL,
                &individual,
                -1);

    if (individual != NULL) {
        contact = empathy_contact_dup_from_folks_individual (individual);
    }

    if (!contact) {
        goto OUT;
    }

    /* If the contact has an event activate it, otherwise the
     * default handler of row-activated will be called. */
    events = empathy_event_manager_get_events (priv->event_manager);
    for (l = events; l; l = l->next) {
        EmpathyEvent *event = l->data;

        if (event->contact == contact) {
            DEBUG ("Activate event");
            empathy_event_activate (event);

            /* We don't want the default handler of this signal
             * (e.g. open a chat) */
            g_signal_stop_emission_by_name (view, "row-activated");
            break;
        }
    }

    g_object_unref (contact);
OUT:
    tp_clear_object (&individual);
}

static void
main_window_row_deleted_cb (GtkTreeModel      *model,
                GtkTreePath       *path,
                EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkTreeIter help_iter;

    if (!gtk_tree_model_get_iter_first (model, &help_iter)) {
        priv->empty = TRUE;

        if (empathy_individual_view_is_searching (
                priv->individual_view)) {
            gchar *tmp;

            tmp = g_strdup_printf ("<b><span size='xx-large'>%s</span></b>",
                _("No match found"));

            gtk_label_set_markup (GTK_LABEL (priv->no_entry_label), tmp);
            g_free (tmp);

            gtk_label_set_line_wrap (GTK_LABEL (priv->no_entry_label),
                TRUE);

            gtk_notebook_set_current_page (
                    GTK_NOTEBOOK (priv->notebook), PAGE_NO_MATCH);
        }
    }
}

static void
main_window_row_inserted_cb (GtkTreeModel      *model,
                 GtkTreePath       *path,
                 GtkTreeIter       *iter,
                 EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);

    if (priv->empty) {
        priv->empty = FALSE;
        gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook),
                PAGE_CONTACT_LIST);
        gtk_widget_grab_focus (GTK_WIDGET (priv->individual_view));
    }
}

static void
main_window_remove_error (EmpathyMainWindow *window,
              TpAccount         *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkWidget *error_widget;

    error_widget = g_hash_table_lookup (priv->errors, account);
    if (error_widget != NULL) {
        gtk_widget_destroy (error_widget);
        g_hash_table_remove (priv->errors, account);
    }
}

static void
main_window_account_disabled_cb (TpAccountManager  *manager,
                 TpAccount         *account,
                 EmpathyMainWindow *window)
{
    main_window_remove_error (window, account);
}

static void
main_window_error_retry_clicked_cb (GtkButton         *button,
                    EmpathyMainWindow *window)
{
    TpAccount *account;

    account = g_object_get_data (G_OBJECT (button), "account");
    tp_account_reconnect_async (account, NULL, NULL);

    main_window_remove_error (window, account);
}

static void
main_window_error_edit_clicked_cb (GtkButton         *button,
                   EmpathyMainWindow *window)
{
    TpAccount *account;

    account = g_object_get_data (G_OBJECT (button), "account");

    empathy_accounts_dialog_show_application (
            gtk_widget_get_screen (GTK_WIDGET (button)),
            account, FALSE, FALSE);

    main_window_remove_error (window, account);
}

static void
main_window_error_close_clicked_cb (GtkButton         *button,
                    EmpathyMainWindow *window)
{
    TpAccount *account;

    account = g_object_get_data (G_OBJECT (button), "account");
    main_window_remove_error (window, account);
}

static void
main_window_error_display (EmpathyMainWindow *window,
               TpAccount         *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkWidget *info_bar;
    GtkWidget *content_area;
    GtkWidget *label;
    GtkWidget *image;
    GtkWidget *retry_button;
    GtkWidget *edit_button;
    GtkWidget *close_button;
    GtkWidget *action_area;
    GtkWidget *action_table;
    gchar     *str;
    const gchar     *icon_name;
    const gchar *error_message;
    gboolean user_requested;

    error_message =
        empathy_account_get_error_message (account, &user_requested);

    if (user_requested) {
        return;
    }

    str = g_markup_printf_escaped ("<b>%s</b>\n%s",
                           tp_account_get_display_name (account),
                           error_message);

    info_bar = g_hash_table_lookup (priv->errors, account);
    if (info_bar) {
        label = g_object_get_data (G_OBJECT (info_bar), "label");

        /* Just set the latest error and return */
        gtk_label_set_markup (GTK_LABEL (label), str);
        g_free (str);

        return;
    }

    info_bar = gtk_info_bar_new ();
    gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_ERROR);

    gtk_widget_set_no_show_all (info_bar, TRUE);
    gtk_box_pack_start (GTK_BOX (priv->errors_vbox), info_bar, FALSE, TRUE, 0);
    gtk_widget_show (info_bar);

    icon_name = tp_account_get_icon_name (account);
    image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
    gtk_widget_show (image);

    label = gtk_label_new (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    gtk_widget_show (label);
    g_free (str);

    content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
    gtk_box_pack_start (GTK_BOX (content_area), image, FALSE, FALSE, 0);
    gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);

    image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_BUTTON);
    retry_button = gtk_button_new ();
    gtk_button_set_image (GTK_BUTTON (retry_button), image);
    gtk_widget_set_tooltip_text (retry_button, _("Reconnect"));
    gtk_widget_show (retry_button);

    image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON);
    edit_button = gtk_button_new ();
    gtk_button_set_image (GTK_BUTTON (edit_button), image);
    gtk_widget_set_tooltip_text (edit_button, _("Edit Account"));
    gtk_widget_show (edit_button);

    image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON);
    close_button = gtk_button_new ();
    gtk_button_set_image (GTK_BUTTON (close_button), image);
    gtk_widget_set_tooltip_text (close_button, _("Close"));
    gtk_widget_show (close_button);

    action_table = gtk_table_new (1, 3, FALSE);
    gtk_table_set_col_spacings (GTK_TABLE (action_table), 2);
    gtk_widget_show (action_table);

    action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (info_bar));
    gtk_box_pack_start (GTK_BOX (action_area), action_table, FALSE, FALSE, 0);

    gtk_table_attach (GTK_TABLE (action_table), retry_button, 0, 1, 0, 1,
                                        (GtkAttachOptions) (GTK_SHRINK),
                                        (GtkAttachOptions) (GTK_SHRINK), 0, 0);
    gtk_table_attach (GTK_TABLE (action_table), edit_button, 1, 2, 0, 1,
                                        (GtkAttachOptions) (GTK_SHRINK),
                                        (GtkAttachOptions) (GTK_SHRINK), 0, 0);
    gtk_table_attach (GTK_TABLE (action_table), close_button, 2, 3, 0, 1,
                                        (GtkAttachOptions) (GTK_SHRINK),
                                        (GtkAttachOptions) (GTK_SHRINK), 0, 0);

    g_object_set_data (G_OBJECT (info_bar), "label", label);
    g_object_set_data_full (G_OBJECT (info_bar),
                "account", g_object_ref (account),
                g_object_unref);
    g_object_set_data_full (G_OBJECT (edit_button),
                "account", g_object_ref (account),
                g_object_unref);
    g_object_set_data_full (G_OBJECT (close_button),
                "account", g_object_ref (account),
                g_object_unref);
    g_object_set_data_full (G_OBJECT (retry_button),
                "account", g_object_ref (account),
                g_object_unref);

    g_signal_connect (edit_button, "clicked",
              G_CALLBACK (main_window_error_edit_clicked_cb),
              window);
    g_signal_connect (close_button, "clicked",
              G_CALLBACK (main_window_error_close_clicked_cb),
              window);
    g_signal_connect (retry_button, "clicked",
              G_CALLBACK (main_window_error_retry_clicked_cb),
              window);

    gtk_widget_set_tooltip_text (priv->errors_vbox, error_message);
    gtk_widget_show (priv->errors_vbox);

    g_hash_table_insert (priv->errors, g_object_ref (account), info_bar);
}

static void
main_window_update_status (EmpathyMainWindow *window)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    gboolean connected, connecting;
    GList *l, *children;

    connected = empathy_account_manager_get_accounts_connected (&connecting);

    /* Update the spinner state */
    if (connecting) {
        gtk_spinner_start (GTK_SPINNER (priv->throbber));
        gtk_widget_show (priv->throbber_tool_item);
    } else {
        gtk_spinner_stop (GTK_SPINNER (priv->throbber));
        gtk_widget_hide (priv->throbber_tool_item);
    }

    /* Update widgets sensibility */
    for (l = priv->actions_connected; l; l = l->next) {
        gtk_action_set_sensitive (l->data, connected);
    }

    /* Update favourite rooms sensitivity */
    children = gtk_container_get_children (GTK_CONTAINER (priv->room_menu));
    for (l = children; l != NULL; l = l->next) {
        if (g_object_get_data (G_OBJECT (l->data), "is_favorite") != NULL) {
            gtk_widget_set_sensitive (GTK_WIDGET (l->data), connected);
        }
    }
    g_list_free (children);
}

static char *
main_window_account_to_action_name (TpAccount *account)
{
    char *r;

    /* action names can't have '/' in them, replace it with '.' */
    r = g_strdup (tp_account_get_path_suffix (account));
    r = g_strdelimit (r, "/", '.');

    return r;
}

static void
main_window_balance_activate_cb (GtkAction         *action,
                 EmpathyMainWindow *window)
{
    const char *uri;

    uri = g_object_get_data (G_OBJECT (action), "manage-credit-uri");

    if (!tp_str_empty (uri)) {
        DEBUG ("Top-up credit URI: %s", uri);
        empathy_url_show (GTK_WIDGET (window), uri);
    } else {
        DEBUG ("unknown protocol for top-up");
    }
}

static void
main_window_balance_update_balance (GtkAction   *action,
                    TpConnection *conn)
{
    TpAccount *account = tp_connection_get_account (conn);
    GtkWidget *label;
    int amount = 0;
    guint scale = G_MAXINT32;
    const gchar *currency = "";
    char *money, *str;

    if (!tp_connection_get_balance (conn, &amount, &scale, &currency))
        return;

    if (amount == 0 &&
        scale == G_MAXINT32 &&
        tp_str_empty (currency)) {
        /* unknown balance */
        money = g_strdup ("--");
    } else {
        char *tmp = empathy_format_currency (amount, scale, currency);

        money = g_strdup_printf ("%s %s", currency, tmp);
        g_free (tmp);
    }

    /* Translators: this string will be something like:
     *   Top up My Account ($1.23)..." */
    str = g_strdup_printf (_("Top up %s (%s)..."),
        tp_account_get_display_name (account),
        money);

    gtk_action_set_label (action, str);
    g_free (str);

    /* update the money label in the roster */
    label = g_object_get_data (G_OBJECT (action), "money-label");

    gtk_label_set_text (GTK_LABEL (label), money);
    g_free (money);
}

static void
main_window_balance_changed_cb (TpConnection      *conn,
                guint balance,
                guint scale,
                const gchar *currency,
                GtkAction *action)
{
    main_window_balance_update_balance (action, conn);
}

static GtkAction *
main_window_setup_balance_create_action (EmpathyMainWindow *window,
                     TpAccount *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkAction *action;
    char *name, *ui;
    guint merge_id;
    GError *error = NULL;

    /* create the action group if required */
    if (priv->balance_action_group == NULL) {
        priv->balance_action_group =
            gtk_action_group_new ("balance-action-group");

        gtk_ui_manager_insert_action_group (priv->ui_manager,
            priv->balance_action_group, -1);
    }

    /* create the action */
    name = main_window_account_to_action_name (account);
    action = gtk_action_new (name,
        tp_account_get_display_name (account),
        _("Top up account credit"),
        NULL);
    g_object_bind_property (account, "icon-name", action, "icon-name",
        G_BINDING_SYNC_CREATE);

    g_signal_connect (action, "activate",
        G_CALLBACK (main_window_balance_activate_cb), window);

    gtk_action_group_add_action (priv->balance_action_group, action);
    g_object_unref (action);

    ui = g_strdup_printf (
        "<ui>"
        " <menubar name='menubar'>"
        "  <menu action='view'>"
        "   <placeholder name='view_balance_placeholder'>"
        "    <menuitem action='%s'/>"
        "   </placeholder>"
        "  </menu>"
        " </menubar>"
        "</ui>",
        name);

    merge_id = gtk_ui_manager_add_ui_from_string (priv->ui_manager,
        ui, -1, &error);
    if (error != NULL) {
        DEBUG ("Failed to add balance UI for %s: %s",
            tp_account_get_display_name (account),
            error->message);
        g_error_free (error);
    }

    g_object_set_data (G_OBJECT (action),
        "merge-id", GUINT_TO_POINTER (merge_id));

    g_free (name);
    g_free (ui);

    return action;
}

static GtkWidget *
main_window_setup_balance_create_widget (EmpathyMainWindow *window,
                     GtkAction         *action,
                     TpAccount *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkWidget *hbox, *image, *label, *button;

    hbox = gtk_hbox_new (FALSE, 6);

    /* protocol icon */
    image = gtk_image_new ();
    gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
    g_object_bind_property (action, "icon-name", image, "icon-name",
        G_BINDING_SYNC_CREATE);

    /* account name label */
    label = gtk_label_new ("");
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
    gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
    g_object_bind_property (account, "display-name", label, "label",
        G_BINDING_SYNC_CREATE);

    /* balance label */
    label = gtk_label_new ("");
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
    gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
    g_object_set_data (G_OBJECT (action), "money-label", label);

    /* top up button */
    button = gtk_button_new_with_label (_("Top Up..."));
    gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0);
    g_signal_connect_swapped (button, "clicked",
        G_CALLBACK (gtk_action_activate), action);

    gtk_box_pack_start (GTK_BOX (priv->balance_vbox), hbox, FALSE, TRUE, 0);
    gtk_widget_show_all (hbox);

    /* tie the lifetime of the widget to the lifetime of the action */
    g_object_weak_ref (G_OBJECT (action),
        (GWeakNotify) gtk_widget_destroy, hbox);

    return hbox;
}

static void
main_window_setup_balance (EmpathyMainWindow *window,
               TpAccount         *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    TpConnection *conn = tp_account_get_connection (account);
    GtkAction *action;
    const gchar *uri;

    if (conn == NULL)
        return;

    if (!tp_proxy_is_prepared (conn, TP_CONNECTION_FEATURE_BALANCE))
        return;

    DEBUG ("Setting up balance for acct: %s",
        tp_account_get_display_name (account));

    /* create the action */
    action = main_window_setup_balance_create_action (window, account);

    if (action == NULL)
        return;

    gtk_action_set_visible (priv->view_balance_show_in_roster, TRUE);

    /* create the display widget */
    main_window_setup_balance_create_widget (window, action, account);

    /* check the current balance and monitor for any changes */
    uri = tp_connection_get_balance_uri (conn);

    g_object_set_data_full (G_OBJECT (action), "manage-credit-uri",
        g_strdup (uri), g_free);
    gtk_action_set_sensitive (GTK_ACTION (action), !tp_str_empty (uri));

    main_window_balance_update_balance (GTK_ACTION (action), conn);

    g_signal_connect (conn, "balance-changed",
        G_CALLBACK (main_window_balance_changed_cb), action);

}

static void
main_window_remove_balance_action (EmpathyMainWindow *window,
                   TpAccount         *account)
{
    EmpathyMainWindowPriv *priv = GET_PRIV (window);
    GtkAction *action;
    char *name;
    GList *a;

    if (priv->balance_action_group == NULL)
        return;

    name = main_window_account_to_action_name (account);

    action = gtk_action_group_get_action (
        priv->balance_action_group, name);

    if (action != NULL) {
        guint merge_id;

        DEBUG ("Removing action");

        merge_id = GPOINTER_TO_UINT (g_object_get_data (
            G_OBJECT (action),
            "merge-id"));

        gtk_ui_manager_remove_ui (priv->ui_manager,
            merge_id);


context:
space:
mode: