git.maemo.org Git - conv-inbox/blob - src/el-home-applet.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
   2 /*
   3  *  Copyright (C) 2009 Artem Garmash. All rights reserved.
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * Contact: Artem Garmash <artemgarmash@gmail.com>
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "el-home-applet.h"
  25
  26 #include <hildon/hildon.h>
  27 #include <rtcom-eventlogger/eventlogger.h>
  28 #include <sqlite3.h>
  29 #include <string.h>
  30 #include <libosso-abook/osso-abook-init.h>
  31 #include <libosso-abook/osso-abook-aggregator.h>
  32 #include <libosso-abook/osso-abook-contact.h>
  33 #include <libosso-abook/osso-abook-waitable.h>
  34 #include <libosso-abook/osso-abook-contact.h>
  35 #include <libosso-abook/osso-abook-touch-contact-starter.h>
  36 #include <libosso-abook/osso-abook-temporary-contact-dialog.h>
  37 #include <libosso-abook/osso-abook-account-manager.h>
  38
  39 #include <telepathy-glib/interfaces.h>
  40 #include <telepathy-glib/dbus.h>
  41 #include <rtcom-telepathy-glib/extensions.h>
  42
  43 #define EL_HOME_APPLET_GET_PRIVATE(obj) ( \
  44         G_TYPE_INSTANCE_GET_PRIVATE (obj, \
  45                 EL_TYPE_HOME_APPLET, ELHomeAppletPrivate))
  46
  47 #define BOX_WIDTH 352
  48 #define BOX_HEIGHT 284
  49
  50 #define CONTENT_OFFSET_X HILDON_MARGIN_HALF
  51 #define CONTENT_OFFSET_Y_TOP 4*HILDON_MARGIN_HALF
  52 #define CONTENT_OFFSET_Y_BOTTOM HILDON_MARGIN_HALF
  53 #define C_WIDTH (BOX_WIDTH - 2*CONTENT_OFFSET_X)
  54 #define C_HEIGHT (BOX_HEIGHT - (CONTENT_OFFSET_Y_TOP + CONTENT_OFFSET_Y_BOTTOM))
  55
  56 #define HEADER_HEIGHT 48
  57 #define FOOTER_HEIGHT 24
  58 #define FOOTER_HEIGHT_PRESS 48 /* approx, used only for checking clicks, bigger than controls */
  59 #define FOOTER_WIDTH C_WIDTH/5
  60
  61 #define MESSAGE_HEIGHT (C_HEIGHT - HEADER_HEIGHT - FOOTER_HEIGHT)
  62 #define MESSAGE_WIDTH (C_WIDTH - 2*HILDON_MARGIN_DEFAULT)
  63
  64 #define BOX_RADIOUS 10
  65
  66 #define SCROLL_PERIOD 100 /* ms */
  67 #define SCROLL_STEP 1 /* pixel */
  68 #define TEXT_Y_OFFSET (HEADER_HEIGHT + HILDON_MARGIN_HALF)
  69
  70 #define NOTIFICATION_UI_DBUS_NAME     "org.freedesktop.Telepathy.Client.NotificationUI"
  71 #define NOTIFICATION_UI_DBUS_PATH     "/org/freedesktop/Telepathy/Client/NotificationUI"
  72 #define NOTIFICATION_UI_DBUS_IFACE    "com.nokia.RtcomNotificationUi"
  73
  74 typedef enum {
  75         SELECTED_NONE,
  76         SELECTED_HEADER,
  77         SELECTED_BODY,
  78         SELECTED_FOOTER
  79 } WidgetActiveSelection;
  80
  81 struct _ELHomeAppletPrivate
  82 {
  83         RTComEl *eventlogger;
  84
  85         GtkWidget *sender;
  86         /* GtkWidget *icon; */
  87         GtkWidget *unread;
  88         GtkWidget *received;
  89         GtkWidget *empty;
  90         GtkWidget *cut_message;
  91         GtkWidget *avatar;
  92
  93         gchar *message;
  94         gint event_id;
  95
  96         WidgetActiveSelection active;
  97
  98         guint unread_count;
  99
 100         struct {
 101                 float red;
 102                 float green;
 103                 float blue;
 104         } active_color;
 105         guint8 border_color[4];
 106         PangoFontDescription *font_desc;
 107
 108         guint idle_id;
 109
 110         cairo_surface_t *message_surface;
 111
 112         gboolean scroll_on_click;
 113         gint scroll_offset;
 114         gint hidden_message_height;
 115         guint scroll_anim_id;
 116
 117         OssoABookRoster *aggregator;
 118         OssoABookWaitableClosure *aggregator_ready_closure;
 119         gchar *contact_id;
 120         gchar *remote_id;
 121         gchar *local_id;
 122         gchar *group_uid;
 123         OssoABookContact *contact;
 124 };
 125
 126 HD_DEFINE_PLUGIN_MODULE (ELHomeApplet, el_home_applet, HD_TYPE_HOME_PLUGIN_ITEM);
 127
 128 const gchar* g_module_check_init (GModule *module);
 129 const gchar*
 130 g_module_check_init (GModule *module)
 131 {
 132         g_module_make_resident (module);
 133         return NULL;
 134 }
 135
 136 static void
 137 el_home_applet_class_finalize (ELHomeAppletClass *klass)
 138 {
 139 }
 140
 141 static void
 142 el_home_applet_realize (GtkWidget *widget)
 143 {
 144         GdkScreen *screen;
 145
 146         screen = gtk_widget_get_screen (widget);
 147         gtk_widget_set_colormap (widget,
 148                                  gdk_screen_get_rgba_colormap (screen));
 149
 150         gtk_widget_set_app_paintable (widget,
 151                                       TRUE);
 152
 153         GTK_WIDGET_CLASS (el_home_applet_parent_class)->realize (widget);
 154 }
 155
 156 /*
 157  * Thanks http://cairographics.org/cookbook/roundedrectangles/
 158  */
 159 static void
 160 rounded_rectangle (cairo_t *cr,
 161                    double   x,
 162                    double   y,
 163                    double   w,
 164                    double   h,
 165                    double   r)
 166 {
 167         cairo_move_to (cr, x + r, y);
 168         cairo_line_to (cr, x + w - r, y);
 169         cairo_curve_to (cr, x + w, y,
 170                         x + w, y,
 171                         x + w, y + r);
 172         cairo_line_to (cr, x + w, y + h - r);
 173         cairo_curve_to (cr, x + w, y + h,
 174                         x + w, y + h,
 175                         x + w - r, y + h);
 176         cairo_line_to (cr, x + r, y + h);
 177         cairo_curve_to (cr, x, y + h,
 178                         x, y + h,
 179                         x, y + h - r);
 180         cairo_line_to (cr, x, y + r);
 181         cairo_curve_to (cr, x, y,
 182                         x, y,
 183                         x + r, y);
 184 }
 185
 186 static cairo_surface_t*
 187 draw_text (cairo_t              *cr,
 188            PangoFontDescription *desc,
 189            const gchar          *text,
 190            gint                  width,
 191            gint                 *height)
 192 {
 193         PangoLayout *layout;
 194         PangoRectangle extent;
 195
 196         cairo_surface_t *gdk_surface, *result_surface;
 197         cairo_t *msg_cr;
 198
 199         /* Create a PangoLayout, set the font and text */
 200         layout = pango_cairo_create_layout (cr);
 201         pango_layout_set_text (layout,
 202                                text,
 203                                -1);
 204         pango_layout_set_font_description (layout, desc);
 205
 206         pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
 207         pango_layout_set_width (layout, PANGO_SCALE*width);
 208
 209         pango_layout_get_pixel_extents (layout, NULL, &extent);
 210         *height = extent.height;
 211
 212         gdk_surface = cairo_get_target (cr);
 213         result_surface = cairo_surface_create_similar
 214                 (gdk_surface,
 215                  CAIRO_CONTENT_COLOR_ALPHA,
 216                  width,
 217                  extent.height);
 218         msg_cr = cairo_create (result_surface);
 219
 220         pango_cairo_update_layout (msg_cr, layout);
 221         /* draw shadow */
 222         cairo_move_to (msg_cr, 1, 1);
 223         cairo_set_source_rgba (msg_cr, 0.2, 0.2, 0.2, 0.8);
 224         pango_cairo_show_layout (msg_cr, layout);
 225
 226         /* draw fg */
 227         cairo_move_to (msg_cr, 0, 0);
 228         cairo_set_source_rgba (msg_cr, 1.0, 1.0, 1.0, 1.0);
 229         pango_cairo_show_layout (msg_cr, layout);
 230
 231         cairo_destroy (msg_cr);
 232         g_object_unref (layout);
 233
 234         return result_surface;
 235 }
 236
 237 static gboolean
 238 stop_scroll_anim (ELHomeAppletPrivate *priv)
 239 {
 240         gboolean result = priv->scroll_anim_id > 0;
 241
 242         if (result) {
 243                 g_source_remove (priv->scroll_anim_id);
 244                 priv->scroll_anim_id = 0;
 245                 priv->scroll_on_click = FALSE;
 246                 gtk_widget_hide (priv->cut_message);
 247         }
 248
 249         return result;
 250 }
 251
 252 static void
 253 style_set_cb (GtkWidget *widget,
 254               GtkStyle  *previous_style,
 255               ELHomeApplet *self)
 256 {
 257         ELHomeAppletPrivate *priv = self->priv;
 258         GdkColor color;
 259         GtkStyle *font_style;
 260
 261         font_style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
 262                                                 "SystemFont",
 263                                                 NULL,
 264                                                 G_TYPE_NONE);
 265         if (font_style && font_style->font_desc) {
 266                 if (priv->font_desc)
 267                         pango_font_description_free (priv->font_desc);
 268                 priv->font_desc = pango_font_description_copy (font_style->font_desc);
 269         }
 270
 271         if (gtk_style_lookup_color (widget->style,
 272                                     "ActiveTextColor",
 273                                     &color)) {
 274                 priv->active_color.red = color.red/(float)G_MAXUINT16;
 275                 priv->active_color.green = color.green/(float)G_MAXUINT16;
 276                 priv->active_color.blue = color.blue/(float)G_MAXUINT16;
 277
 278                 priv->border_color[0] = color.red;
 279                 priv->border_color[1] = color.green;
 280                 priv->border_color[2] = color.blue;
 281                 priv->border_color[3] = 255;
 282         }
 283 }
 284
 285 static void
 286 reset_scroll (ELHomeApplet *self)
 287 {
 288         ELHomeAppletPrivate *priv = self->priv;
 289
 290         if (stop_scroll_anim (self->priv)) {
 291                 priv->scroll_on_click = TRUE;/* priv->scroll_offset; */
 292                 priv->scroll_offset = 0;
 293                 if (priv->scroll_on_click)
 294                         gtk_widget_show (priv->cut_message);
 295         }
 296 }
 297
 298 static void
 299 notify_on_current_desktop (GObject      *object,
 300                            GParamSpec   *unused G_GNUC_UNUSED,
 301                            ELHomeApplet *self)
 302 {
 303         gboolean on;
 304
 305         g_object_get (object, "is-on-current-desktop", &on, NULL);
 306         if (!on) {
 307                 reset_scroll (self);
 308                 gtk_widget_queue_draw (GTK_WIDGET (self));
 309         }
 310 }
 311
 312 static gboolean
 313 expose_event (GtkWidget *self, GdkEventExpose *event)
 314 {
 315         ELHomeAppletPrivate *priv = EL_HOME_APPLET(self)->priv;
 316         cairo_t *cr;
 317         cairo_pattern_t *grad;
 318
 319         cr = gdk_cairo_create (self->window);
 320         gdk_cairo_region (cr, event->region);
 321         cairo_clip (cr);
 322
 323         cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 324
 325         /* draw bound box */
 326         cairo_set_source_rgba (cr, 0.4f, 0.4f, 0.4f, 0.1f);
 327         cairo_set_line_width (cr, 3.0f);
 328
 329         rounded_rectangle (cr,
 330                            CONTENT_OFFSET_X,
 331                            CONTENT_OFFSET_Y_TOP,
 332                            BOX_WIDTH - 2*CONTENT_OFFSET_X,
 333                            BOX_HEIGHT - (CONTENT_OFFSET_Y_TOP + CONTENT_OFFSET_Y_BOTTOM),
 334                            BOX_RADIOUS);
 335
 336         cairo_close_path (cr);
 337         cairo_stroke (cr);
 338
 339         /* draw header */
 340         cairo_set_line_width (cr, 1.0f);
 341
 342         cairo_translate (cr, CONTENT_OFFSET_X, CONTENT_OFFSET_Y_TOP);
 343         cairo_move_to (cr, 0, HEADER_HEIGHT);
 344         cairo_line_to (cr, 0, BOX_RADIOUS);
 345         cairo_curve_to (cr, 0, 0, 0, 0, BOX_RADIOUS, 0);
 346         cairo_line_to (cr, C_WIDTH - BOX_RADIOUS, 0);
 347         cairo_curve_to (cr, C_WIDTH, 0, C_WIDTH, 0, C_WIDTH, BOX_RADIOUS);
 348         cairo_line_to (cr, C_WIDTH, HEADER_HEIGHT);
 349         cairo_line_to (cr, 0, HEADER_HEIGHT);
 350
 351         cairo_close_path (cr);
 352
 353         switch (priv->active) {
 354         case SELECTED_HEADER:
 355                 cairo_set_source_rgba (cr,
 356                                        priv->active_color.red,
 357                                        priv->active_color.green,
 358                                        priv->active_color.blue,
 359                                        0.8f);
 360                 break;
 361         default:
 362                 cairo_set_source_rgba (cr, 0.2f, 0.2f, 0.2f, 0.8f);
 363         }
 364
 365         cairo_fill (cr);
 366
 367         cairo_move_to (cr, 0, HEADER_HEIGHT);
 368         cairo_line_to (cr, C_WIDTH, HEADER_HEIGHT);
 369         cairo_set_source_rgba (cr,
 370                                priv->active_color.red,
 371                                priv->active_color.green,
 372                                priv->active_color.blue,
 373                                1.0f);
 374         cairo_stroke (cr);
 375
 376         /* draw body */
 377         if (!priv->message) {
 378                 cairo_move_to (cr, 0, HEADER_HEIGHT);
 379                 cairo_line_to (cr, 0, C_HEIGHT - BOX_RADIOUS);
 380                 cairo_curve_to (cr, 0, C_HEIGHT, 0, C_HEIGHT, BOX_RADIOUS, C_HEIGHT);
 381                 cairo_line_to (cr, C_WIDTH - BOX_RADIOUS, C_HEIGHT);
 382                 cairo_curve_to (cr, C_WIDTH, C_HEIGHT, C_WIDTH, C_HEIGHT, C_WIDTH, C_HEIGHT - BOX_RADIOUS);
 383                 cairo_line_to (cr, C_WIDTH, HEADER_HEIGHT);
 384                 cairo_line_to (cr, 0, HEADER_HEIGHT);
 385                 cairo_close_path (cr);
 386         }
 387         else
 388                 cairo_rectangle (cr, 0, HEADER_HEIGHT,
 389                                  C_WIDTH, MESSAGE_HEIGHT);
 390
 391         /* draw body filling depending on (in)active state */
 392         grad = cairo_pattern_create_linear (0, HEADER_HEIGHT,
 393                                             0, C_HEIGHT - FOOTER_HEIGHT);
 394
 395         switch (priv->active) {
 396         case SELECTED_BODY:
 397                 cairo_pattern_add_color_stop_rgba (grad,
 398                                                    0.5f,
 399                                                    priv->active_color.red,
 400                                                    priv->active_color.green,
 401                                                    priv->active_color.blue,
 402                                                    0.8f);
 403                 cairo_pattern_add_color_stop_rgba (grad,
 404                                                    1.0f,
 405                                                    priv->active_color.red/2,
 406                                                    priv->active_color.green/2,
 407                                                    priv->active_color.blue/2,
 408                                                    0.8f);
 409                 break;
 410         default:
 411                 cairo_pattern_add_color_stop_rgba (grad, 0.5f,
 412                                                    0.4f, 0.4f, 0.4f, 0.8f);
 413                 cairo_pattern_add_color_stop_rgba (grad, 1.0f,
 414                                                    0.2f, 0.2f, 0.2f, 0.8f);
 415         }
 416
 417         cairo_set_source (cr, grad);
 418         cairo_fill (cr);
 419
 420         cairo_pattern_destroy (grad);
 421
 422         if (priv->message) {
 423                 /* draw footer unread part bg */
 424                 cairo_move_to (cr, 0, C_HEIGHT - FOOTER_HEIGHT);
 425                 cairo_line_to (cr, 0, C_HEIGHT - BOX_RADIOUS);
 426                 cairo_curve_to (cr, 0, C_HEIGHT, 0, C_HEIGHT, BOX_RADIOUS, C_HEIGHT);
 427                 cairo_line_to (cr, FOOTER_WIDTH, C_HEIGHT);
 428                 cairo_line_to (cr, FOOTER_WIDTH, C_HEIGHT - FOOTER_HEIGHT);
 429                 cairo_line_to (cr, 0, C_HEIGHT - FOOTER_HEIGHT);
 430                 cairo_close_path (cr);
 431
 432                 /* draw body filling depending on (in)active state */
 433                 switch (priv->active) {
 434                 case SELECTED_FOOTER:
 435                         cairo_set_source_rgba (cr,
 436                                                priv->active_color.red,
 437                                                priv->active_color.green,
 438                                                priv->active_color.blue,
 439                                                0.8f);
 440                         break;
 441                 default:
 442                         cairo_set_source_rgba (cr, 0.1f, 0.1f, 0.1f, 0.9f);
 443                 }
 444                 cairo_fill (cr);
 445
 446                 /* draw footer received part bg */
 447                 cairo_move_to (cr, FOOTER_WIDTH, C_HEIGHT - FOOTER_HEIGHT);
 448                 cairo_rel_line_to (cr, 0, FOOTER_HEIGHT);
 449                 cairo_rel_line_to (cr, C_WIDTH - FOOTER_WIDTH - BOX_RADIOUS, 0);
 450                 cairo_rel_curve_to (cr, BOX_RADIOUS, 0, BOX_RADIOUS, 0, BOX_RADIOUS, -BOX_RADIOUS);
 451                 cairo_rel_line_to (cr, 0, -(FOOTER_HEIGHT - BOX_RADIOUS));
 452                 cairo_rel_line_to (cr, -(C_WIDTH - FOOTER_WIDTH), 0);
 453                 cairo_close_path (cr);
 454
 455                 cairo_set_source_rgba (cr, 0.2f, 0.2f, 0.2f, 0.8f);
 456                 cairo_fill (cr);
 457
 458                 /* draw message */
 459                 if (!priv->message_surface) {
 460                         gint height;
 461
 462                         priv->message_surface = draw_text (cr,
 463                                                            priv->font_desc,
 464                                                            priv->message,
 465                                                            MESSAGE_WIDTH,
 466                                                            &height);
 467
 468                         priv->hidden_message_height = height - MESSAGE_HEIGHT;
 469                         priv->scroll_on_click = priv->hidden_message_height > 0;
 470                         if (priv->scroll_on_click)
 471                                 gtk_widget_show (priv->cut_message);
 472                 }
 473
 474                 cairo_rectangle (cr,
 475                                  2*CONTENT_OFFSET_X,
 476                                  TEXT_Y_OFFSET,
 477                                  MESSAGE_WIDTH,
 478                                  MESSAGE_HEIGHT);
 479                 cairo_clip (cr);
 480
 481                 cairo_set_source_surface (cr,
 482                                           priv->message_surface,
 483                                           2*CONTENT_OFFSET_X,
 484                                           TEXT_Y_OFFSET - priv->scroll_offset);
 485                 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 486                 cairo_paint (cr);
 487         }
 488
 489         cairo_destroy (cr);
 490
 491         return GTK_WIDGET_CLASS (el_home_applet_parent_class)->expose_event (self, event);
 492 }
 493
 494
 495 static void
 496 clean_state (ELHomeApplet *self)
 497 {
 498         ELHomeAppletPrivate *priv = self->priv;
 499
 500         if (priv->message) {
 501                 g_free (priv->message);
 502                 priv->message = NULL;
 503         }
 504
 505         if (priv->contact_id) {
 506                 g_free (priv->contact_id);
 507                 priv->contact_id = NULL;
 508         }
 509         if (priv->local_id) {
 510                 g_free (priv->local_id);
 511                 priv->local_id = NULL;
 512         }
 513         if (priv->remote_id) {
 514                 g_free (priv->remote_id);
 515                 priv->remote_id = NULL;
 516         }
 517         if (priv->group_uid) {
 518                 g_free (priv->group_uid);
 519                 priv->group_uid = NULL;
 520         }
 521
 522         if (priv->contact) {
 523                 g_object_unref (priv->contact);
 524                 priv->contact = NULL;
 525         }
 526         if (priv->aggregator) {
 527                 if (priv->aggregator_ready_closure){
 528                         osso_abook_waitable_cancel (OSSO_ABOOK_WAITABLE (priv->aggregator),
 529                                                     priv->aggregator_ready_closure);
 530                         priv->aggregator_ready_closure = NULL;
 531                 }
 532                 osso_abook_roster_stop (priv->aggregator);
 533                 g_object_unref (priv->aggregator);
 534                 priv->aggregator = NULL;
 535         }
 536 }
 537
 538 static void
 539 dispose (GObject *self)
 540 {
 541         ELHomeAppletPrivate *priv = EL_HOME_APPLET(self)->priv;
 542
 543         stop_scroll_anim (priv);
 544         if (priv->idle_id) {
 545                 g_source_remove (priv->idle_id);
 546                 priv->idle_id = 0;
 547         }
 548         if (priv->eventlogger) {
 549                 g_object_unref (priv->eventlogger);
 550                 priv->eventlogger = NULL;
 551         }
 552         if (priv->font_desc) {
 553                 pango_font_description_free (priv->font_desc);
 554                 priv->font_desc = NULL;
 555         }
 556
 557         clean_state (EL_HOME_APPLET (self));
 558
 559         G_OBJECT_CLASS (el_home_applet_parent_class)->dispose (self);
 560 }
 561
 562 static void
 563 finalize (GObject *self)
 564 {
 565         G_OBJECT_CLASS (el_home_applet_parent_class)->finalize (self);
 566 }
 567
 568 static void
 569 aggregator_ready_cb (OssoABookWaitable *waitable,
 570                      const GError      *error,
 571                      gpointer           userdata)
 572 {
 573         ELHomeApplet *self = EL_HOME_APPLET(userdata);
 574         ELHomeAppletPrivate *priv = self->priv;
 575         GList *contacts = NULL;
 576
 577         priv->aggregator_ready_closure = NULL;
 578
 579         if (error) {
 580                 g_warning ("Failed to create aggregator: %s", error->message);
 581                 return;
 582         }
 583
 584         if (priv->contact_id) {
 585                 contacts = osso_abook_aggregator_lookup
 586                         (OSSO_ABOOK_AGGREGATOR (priv->aggregator),
 587                          priv->contact_id);
 588         }
 589         else if (priv->local_id && priv->remote_id) {
 590                 if (g_strcmp0 (priv->local_id, "ring/tel/ring" == 0)) {
 591                         contacts = osso_abook_aggregator_find_contacts_for_phone_number
 592                                 (OSSO_ABOOK_AGGREGATOR (priv->aggregator),
 593                                  priv->remote_id,
 594                                  TRUE);
 595                 }
 596                 else {
 597                         McAccount *account;
 598                         account = osso_abook_account_manager_lookup_by_name
 599                                 (NULL,
 600                                  priv->local_id);
 601                         if (account) {
 602                                 contacts = osso_abook_aggregator_find_contacts_for_im_contact
 603                                         (OSSO_ABOOK_AGGREGATOR (priv->aggregator),
 604                                          priv->remote_id,
 605                                          account);
 606                         }
 607                 }
 608         }
 609
 610         if (contacts && contacts->data) {
 611                 GdkPixbuf *avatar_image;
 612
 613                 priv->contact = g_object_ref (OSSO_ABOOK_CONTACT (contacts->data));
 614                 gtk_label_set_text (GTK_LABEL (priv->sender),
 615                                     osso_abook_contact_get_display_name (priv->contact));
 616
 617                 avatar_image = osso_abook_avatar_get_image_rounded
 618                         (OSSO_ABOOK_AVATAR (priv->contact),
 619                          HILDON_ICON_PIXEL_SIZE_THUMB,
 620                          HILDON_ICON_PIXEL_SIZE_THUMB,
 621                          TRUE,
 622                          -1,
 623                          priv->border_color);
 624
 625                 if (avatar_image) {
 626                         gtk_image_set_from_pixbuf (GTK_IMAGE (priv->avatar),
 627                                                    avatar_image);
 628                         gtk_widget_show (priv->avatar);
 629                         g_object_unref (avatar_image);
 630                 }
 631                 gtk_widget_queue_draw (GTK_WIDGET (self));
 632         }
 633 }
 634
 635 static void
 636 resolve_contact (ELHomeApplet *self)
 637 {
 638         ELHomeAppletPrivate *priv = self->priv;
 639         EBookQuery *query = NULL;
 640         GError *error = NULL;
 641
 642         if (priv->local_id && priv->remote_id) {
 643                 const gchar *vcard = osso_abook_account_manager_get_vcard_field
 644                         (NULL, priv->local_id);
 645                 if (vcard)
 646                         query = e_book_query_vcard_field_test (vcard,
 647                                                                E_BOOK_QUERY_IS,
 648                                                                priv->remote_id);
 649                 else
 650                         query = e_book_query_any_field_contains (priv->remote_id);
 651         }
 652
 653         if (query) {
 654                 priv->aggregator = osso_abook_aggregator_new_with_query (NULL,
 655                                                                          query,
 656                                                                          NULL,
 657                                                                          1,
 658                                                                          &error);
 659                 e_book_query_unref (query);
 660         }
 661         if (error) {
 662                 g_warning ("Failed to create aggregator: %s", error->message);
 663                 g_error_free (error);
 664                 return;
 665         }
 666
 667         if (priv->aggregator) {
 668                 priv->aggregator_ready_closure = osso_abook_waitable_call_when_ready
 669                         (OSSO_ABOOK_WAITABLE (priv->aggregator),
 670                          aggregator_ready_cb,
 671                          self, NULL);
 672
 673                 osso_abook_roster_start (priv->aggregator);
 674         }
 675 }
 676
 677 static gchar*
 678 format_time (time_t t)
 679 {
 680         static const guint RESULT_SIZE = 32;
 681
 682         time_t now;
 683         struct tm now_tm, t_tm;
 684         const gchar *format = "%x %X";
 685         gchar *result = g_malloc0 (RESULT_SIZE);
 686
 687         now = time (NULL);
 688         localtime_r (&now, &now_tm);
 689         localtime_r (&t, &t_tm);
 690
 691         if ((now_tm.tm_year == t_tm.tm_year) &&
 692             (now_tm.tm_mon  == t_tm.tm_mon) &&
 693             (now_tm.tm_mday == t_tm.tm_mday))
 694                 format = "%X";
 695
 696         strftime (result, RESULT_SIZE, format, &t_tm);
 697
 698         return result;
 699 }
 700
 701 static void
 702 show_event (ELHomeApplet *self, RTComElIter *it)
 703 {
 704         ELHomeAppletPrivate *priv = self->priv;
 705         gchar *remote = NULL;
 706         gchar *received = NULL;
 707         /* const gchar *icon_name = NULL; */
 708
 709         if (it && rtcom_el_iter_first (it)) {
 710                 rtcom_el_iter_dup_string (it, "free-text", &priv->message);
 711                 if (priv->message) {
 712                         /* const gchar *service; */
 713                         time_t received_t;
 714
 715                         rtcom_el_iter_get_int (it, "id", &priv->event_id);
 716                         if (rtcom_el_iter_get_int (it, "start-time", (gint*)&received_t))
 717                                 received = format_time (received_t);
 718
 719                         if (rtcom_el_iter_dup_string (it, "remote-uid", &priv->remote_id)) {
 720                                 if (priv->remote_id && priv->remote_id[0])  {
 721                                         if (!rtcom_el_iter_dup_string (it, "remote-name", &remote))
 722                                                 remote = g_strdup (priv->remote_id);
 723
 724                                         rtcom_el_iter_dup_string (it, "remote-ebook-uid", &priv->contact_id);
 725                                         rtcom_el_iter_dup_string (it, "local-uid", &priv->local_id);
 726                                 }
 727                                 else if (priv->remote_id) {
 728                                         g_free (priv->remote_id);
 729                                         priv->remote_id = NULL;
 730                                 }
 731                         }
 732                         rtcom_el_iter_dup_string (it, "group-uid", &priv->group_uid);
 733 #if 0
 734                         service = rtcom_el_iter_get_service (it);
 735                         if (!g_strcmp0 (service, "RTCOM_EL_SERVICE_SMS"))
 736                                 icon_name = "chat_unread_sms";
 737                         else if (!g_strcmp0 (service, "RTCOM_EL_SERVICE_CHAT"))
 738                                 icon_name = "chat_unread_chat";
 739 #endif
 740                 }
 741         }
 742         else {
 743                 priv->event_id = -1;
 744         }
 745
 746         gtk_widget_hide (priv->avatar);
 747
 748         if (priv->message) {
 749                 gtk_widget_hide (priv->empty);
 750         }
 751         else {
 752                 gtk_widget_show (priv->empty);
 753         }
 754
 755         gtk_label_set_text (GTK_LABEL (priv->received), received);
 756
 757 #if 0
 758         gtk_widget_hide (priv->avatar);
 759         if (icon_name) {
 760                 const gchar *current_icon_name;
 761                 gtk_image_get_icon_name (GTK_IMAGE (priv->icon),
 762                                          &current_icon_name,
 763                                          NULL);
 764                 if (g_strcmp0 (current_icon_name, icon_name))
 765                         gtk_image_set_from_icon_name (GTK_IMAGE (priv->icon),
 766                                                       icon_name,
 767                                                       HILDON_ICON_SIZE_FINGER);
 768                 gtk_widget_show (priv->icon);
 769         }
 770         else
 771                 gtk_widget_hide (priv->icon);
 772 #endif
 773
 774         if (remote)
 775                 gtk_label_set_text (GTK_LABEL (priv->sender), remote);
 776         else
 777                 gtk_label_set_text (GTK_LABEL (priv->sender), priv->remote_id);
 778         g_free (remote);
 779
 780         stop_scroll_anim (priv);
 781         priv->scroll_offset = 0;
 782         if (priv->message_surface) {
 783                 cairo_surface_destroy (priv->message_surface);
 784                 priv->message_surface = NULL;
 785         }
 786
 787         gtk_widget_hide (priv->cut_message);
 788         gtk_widget_queue_draw (GTK_WIDGET (self));
 789 }
 790
 791 static RTComElIter*
 792 make_query (RTComEl *el, gint event_id)
 793 {
 794         RTComElQuery *query = NULL;
 795         RTComElIter *it = NULL;
 796
 797         static const gchar *services[] = {"RTCOM_EL_SERVICE_SMS",
 798                                           "RTCOM_EL_SERVICE_CHAT",
 799                                           NULL};
 800         static const gchar *event_types[] = {"RTCOM_EL_EVENTTYPE_SMS_INBOUND",
 801                                              "RTCOM_EL_EVENTTYPE_CHAT_INBOUND",
 802                                              NULL};
 803
 804         query = rtcom_el_query_new (el);
 805         rtcom_el_query_set_limit (query, 1);
 806         if (event_id >= 0) {
 807                 rtcom_el_query_prepare (query,
 808                                         "is-read", FALSE, RTCOM_EL_OP_EQUAL,
 809                                         "id", event_id, RTCOM_EL_OP_EQUAL,
 810                                         "service", services, RTCOM_EL_OP_IN_STRV,
 811                                         "event-type", event_types, RTCOM_EL_OP_IN_STRV,
 812                                         NULL);
 813         }
 814         else {
 815                 rtcom_el_query_prepare (query,
 816                                         "is-read", FALSE, RTCOM_EL_OP_EQUAL,
 817                                         "service", services, RTCOM_EL_OP_IN_STRV,
 818                                         "event-type", event_types, RTCOM_EL_OP_IN_STRV,
 819                                         NULL);
 820         }
 821         it = rtcom_el_get_events (el, query);
 822         g_object_unref (query);
 823
 824         return it;
 825 }
 826
 827 static void
 828 update_unread_label (ELHomeApplet *self)
 829 {
 830         ELHomeAppletPrivate *priv = self->priv;
 831
 832         if (priv->unread_count > 0) {
 833                 gchar *text;
 834                 text = g_strdup_printf
 835                         ("%d<span foreground=\"red\" rise=\"5000\">*</span>",
 836                          priv->unread_count);
 837
 838                 gtk_label_set_markup (GTK_LABEL (priv->unread), text);
 839                 g_free (text);
 840         }
 841         else
 842                 gtk_label_set_text (GTK_LABEL (priv->unread), NULL);
 843 }
 844
 845 static gint
 846 query_unread_events (RTComEl *el)
 847 {
 848         sqlite3 *db;
 849         sqlite3_stmt *stmt;
 850         int ret;
 851         gint count = 0;
 852
 853         g_object_get (el, "db", &db, NULL);
 854
 855         if (sqlite3_prepare_v2 (db,
 856                                 "SELECT SUM(total_events)-SUM(read_events) FROM GroupCache;",
 857                                 -1,
 858                                 &stmt,
 859                                 NULL) != SQLITE_OK) {
 860                 g_error ("%s: can't compile SQL", G_STRFUNC);
 861                 return -1;
 862         }
 863
 864         while (SQLITE_BUSY == (ret = sqlite3_step (stmt)));
 865
 866         if (ret == SQLITE_ROW) {
 867                 count = sqlite3_column_int (stmt, 0);
 868         }
 869         else {
 870                 g_error ("%s: error while executing SQL", G_STRFUNC);
 871         }
 872
 873         sqlite3_finalize (stmt);
 874
 875         return count;
 876 }
 877
 878 static void
 879 read_event (ELHomeApplet *self)
 880 {
 881         ELHomeAppletPrivate *priv = self->priv;
 882         RTComElIter *it = NULL;
 883
 884         clean_state (self);
 885
 886         it = make_query (priv->eventlogger, -1);
 887         show_event (self, it);
 888         resolve_contact (self);
 889         if (it) g_object_unref (it);
 890 }
 891
 892 static void
 893 remove_notification (ELHomeApplet *self)
 894 {
 895         ELHomeAppletPrivate *priv = self->priv;
 896
 897         DBusGConnection* conn;
 898         GError *error;
 899         DBusGProxy *proxy;
 900         GPtrArray *conv_structs;
 901         GType conv_structs_type;
 902         GValueArray *account_info;
 903         GValue value = {0, };
 904         DBusGProxyCall *call;
 905
 906         if (!(priv->remote_id && priv->local_id))
 907                 return;
 908
 909         conn = hd_home_plugin_item_get_dbus_g_connection (HD_HOME_PLUGIN_ITEM (self),
 910                                                           DBUS_BUS_SESSION,
 911                                                           &error);
 912         if (!conn) {
 913                 g_error ("Failed get dbus g connection %s", error->message);
 914                 g_error_free (error);
 915                 return;
 916         }
 917
 918         proxy = dbus_g_proxy_new_for_name (conn,
 919                                            NOTIFICATION_UI_DBUS_NAME,
 920                                            NOTIFICATION_UI_DBUS_PATH,
 921                                            NOTIFICATION_UI_DBUS_IFACE);
 922
 923         conv_structs = g_ptr_array_sized_new (1);
 924         account_info = g_value_array_new (2);
 925
 926         g_value_init (&value, G_TYPE_STRING);
 927         g_value_set_string (&value, priv->local_id);
 928         g_value_array_append (account_info, &value);
 929         g_value_unset (&value);
 930
 931         g_value_init (&value, G_TYPE_STRING);
 932         g_value_set_string (&value, priv->remote_id);
 933         g_value_array_append (account_info, &value);
 934         g_value_unset (&value);
 935
 936         g_ptr_array_add (conv_structs, account_info);
 937
 938         conv_structs_type = dbus_g_type_get_collection
 939                 ("GPtrArray",
 940                  dbus_g_type_get_struct ("GValueArray",
 941                                          G_TYPE_STRING,
 942                                          G_TYPE_STRING,
 943                                          G_TYPE_INVALID));
 944
 945         call = dbus_g_proxy_begin_call (proxy,
 946                                         "ClearConversationNotifications",
 947                                         NULL, NULL, NULL,
 948                                         conv_structs_type,
 949                                         conv_structs,
 950                                         G_TYPE_INVALID);
 951
 952         g_value_array_free (account_info);
 953         g_ptr_array_free (conv_structs, TRUE);
 954
 955         g_object_unref (proxy);
 956 }
 957
 958 static void
 959 mark_as_read (ELHomeApplet *self)
 960 {
 961         ELHomeAppletPrivate *priv = self->priv;
 962
 963         if (priv->event_id >= 0) {
 964                 rtcom_el_set_read_event (priv->eventlogger,
 965                                          priv->event_id,
 966                                          TRUE,
 967                                          NULL);
 968                 remove_notification (self);
 969         }
 970 }
 971
 972 static void
 973 open_conversation (ELHomeApplet *self)
 974 {
 975         ELHomeAppletPrivate *priv = self->priv;
 976         McAccount *account;
 977         const gchar *persistent_id = NULL;
 978
 979         if (!((priv->remote_id || priv->group_uid) && priv->local_id))
 980                 return;
 981
 982         account = osso_abook_account_manager_lookup_by_name (NULL,
 983                                                              priv->local_id);
 984         if (!account)
 985                 return;
 986
 987         if (priv->group_uid &&
 988             g_str_has_prefix (priv->group_uid, "group:")) {
 989                 persistent_id = strchr (priv->group_uid, '-');
 990                 if (persistent_id)
 991                         persistent_id++;
 992         }
 993
 994         if (persistent_id && persistent_id[0] != '\0') {
 995                 GHashTable *properties = tp_asv_new
 996                         (TP_IFACE_CHANNEL ".ChannelType", G_TYPE_STRING,
 997                          TP_IFACE_CHANNEL_TYPE_TEXT,
 998                          TP_IFACE_CHANNEL ".TargetHandleType", G_TYPE_UINT,
 999                          TP_HANDLE_TYPE_NONE,
1000                          RTCOM_TP_IFACE_CHANNEL_INTERFACE_PERSISTENT ".PersistentID",
1001                          G_TYPE_STRING, persistent_id,
1002                          NULL);
1003
1004                 mc_account_channelrequest_ht (account,
1005                                               properties,
1006                                               time (NULL),
1007                                               NULL,
1008                                               MC_ACCOUNT_CR_FLAG_USE_EXISTING,
1009                                               NULL, NULL, NULL, NULL);
1010
1011                 g_hash_table_unref (properties);
1012         }
1013         else if (priv->remote_id) {
1014                 McAccountChannelrequestData request;
1015
1016                 MC_ACCOUNT_CRD_INIT (&request);
1017                 MC_ACCOUNT_CRD_SET (&request, channel_type, TP_IFACE_QUARK_CHANNEL_TYPE_TEXT);
1018                 MC_ACCOUNT_CRD_SET (&request, target_handle_type, TP_HANDLE_TYPE_CONTACT);
1019                 MC_ACCOUNT_CRD_SET (&request, target_id, priv->remote_id);
1020
1021                 mc_account_channelrequest (account,
1022                                            &request,
1023                                            time (NULL),
1024                                            NULL,
1025                                            MC_ACCOUNT_CR_FLAG_USE_EXISTING,
1026                                            NULL, NULL, NULL, NULL);
1027         }
1028 }
1029
1030 static gboolean
1031 read_new_event (ELHomeApplet *self)
1032 {
1033         ELHomeAppletPrivate *priv = self->priv;
1034
1035         read_event (self);
1036         priv->unread_count = query_unread_events (priv->eventlogger);
1037         update_unread_label (self);
1038
1039         priv->idle_id = 0;
1040
1041         return FALSE;
1042 }
1043
1044 static void
1045 add_new_idle (ELHomeApplet *self)
1046 {
1047         ELHomeAppletPrivate *priv = self->priv;
1048
1049         if (priv->idle_id)
1050                 g_source_remove (priv->idle_id);
1051         priv->idle_id = g_idle_add ((GSourceFunc)read_new_event,
1052                                     self);
1053 }
1054
1055 static void
1056 new_event_cb (RTComEl      *backend,
1057               gint          event_id,
1058               const gchar  *local_uid,
1059               const gchar  *remote_uid,
1060               const gchar  *remote_ebook_uid,
1061               const gchar  *group_uid,
1062               const gchar  *service,
1063               ELHomeApplet *self)
1064 {
1065         /* TODO: avoid updating if not related */
1066         add_new_idle (self);
1067 }
1068
1069 static gboolean
1070 scroll_anim_cb (ELHomeApplet *self)
1071 {
1072         ELHomeAppletPrivate *priv = self->priv;
1073         gboolean to_continue;
1074
1075         priv->scroll_offset += SCROLL_STEP;
1076         gtk_widget_queue_draw_area (GTK_WIDGET (self),
1077                                     3*CONTENT_OFFSET_X,
1078                                     HEADER_HEIGHT + CONTENT_OFFSET_Y_TOP,
1079                                     MESSAGE_WIDTH,
1080                                     C_HEIGHT - priv->received->allocation.height - HEADER_HEIGHT);
1081
1082         to_continue = priv->scroll_offset <= priv->hidden_message_height;
1083         if (!to_continue) {
1084                 priv->scroll_anim_id = 0;
1085                 gtk_widget_hide (priv->cut_message);
1086         }
1087
1088         return to_continue;
1089 }
1090
1091 static gboolean
1092 button_press_event_cb (GtkWidget      *widget,
1093                        GdkEventButton *event,
1094                        ELHomeApplet   *self)
1095 {
1096         ELHomeAppletPrivate *priv = self->priv;
1097
1098         if (priv->event_id > 0) {
1099                 if (event->y < CONTENT_OFFSET_Y_TOP + HEADER_HEIGHT) {
1100                         if (priv->aggregator &&
1101                             osso_abook_waitable_is_ready
1102                             (OSSO_ABOOK_WAITABLE (priv->aggregator), NULL))
1103                                 priv->active = SELECTED_HEADER;
1104                 }
1105                 else if (event->y > (BOX_HEIGHT - CONTENT_OFFSET_Y_BOTTOM - FOOTER_HEIGHT_PRESS) &&
1106                          event->x < FOOTER_WIDTH)
1107                         priv->active = SELECTED_FOOTER;
1108                 else
1109                         priv->active = SELECTED_BODY;
1110
1111                 gtk_widget_queue_draw (widget);
1112         }
1113
1114         return TRUE;
1115 }
1116
1117 static GtkWidget*
1118 create_contact_starter_dialog (OssoABookAggregator *aggregator, const gchar *contact_id)
1119 {
1120         GtkWidget *dialog = NULL;
1121         GList *contacts = osso_abook_aggregator_lookup (aggregator, contact_id);
1122         if (contacts && contacts->data) {
1123                 GtkWidget *starter =
1124                         osso_abook_touch_contact_starter_new_with_contact
1125                         (NULL,
1126                          OSSO_ABOOK_CONTACT (contacts->data));
1127                 dialog = osso_abook_touch_contact_starter_dialog_new
1128                         (NULL,
1129                          OSSO_ABOOK_TOUCH_CONTACT_STARTER (starter));
1130                 gtk_widget_show_all (starter);
1131         }
1132
1133         g_list_free (contacts);
1134
1135         return dialog;
1136 }
1137
1138 static GtkWidget*
1139 create_temporary_contact_dialog (const gchar *remote_id,
1140                                  const gchar *account_id)
1141 {
1142         GtkWidget *dialog = NULL;
1143         const gchar *vcard = NULL;
1144         McAccount *account = NULL;
1145
1146         if (account_id) {
1147             vcard = osso_abook_account_manager_get_vcard_field (NULL, account_id);
1148             account = osso_abook_account_manager_lookup_by_name (NULL, account_id);
1149         }
1150
1151         if (vcard && account) {
1152                 EVCardAttribute *attribute = e_vcard_attribute_new (NULL, vcard);
1153
1154                 e_vcard_attribute_add_value (attribute, remote_id);
1155                 dialog = osso_abook_temporary_contact_dialog_new
1156                         (NULL,
1157                          NULL, /*EBook            *book,*/
1158                          attribute,
1159                          account);
1160                 g_signal_connect (dialog,
1161                                   "response",
1162                                   G_CALLBACK (gtk_widget_destroy),
1163                                   NULL);
1164                 e_vcard_attribute_free (attribute);
1165         }
1166
1167         return dialog;
1168 }
1169
1170 static gboolean
1171 button_release_event_cb (GtkWidget      *widget,
1172                          GdkEventButton *event,
1173                          ELHomeApplet   *self)
1174 {
1175         ELHomeAppletPrivate *priv = self->priv;
1176
1177         switch (priv->active) {
1178         case SELECTED_BODY:
1179                 reset_scroll (self);
1180                 open_conversation (self);
1181                 break;
1182         case SELECTED_HEADER: {
1183                 GtkWidget *dialog = NULL;
1184
1185                 reset_scroll (self);
1186
1187                 if (priv->aggregator && priv->contact_id)
1188                         dialog = create_contact_starter_dialog
1189                                 (OSSO_ABOOK_AGGREGATOR (priv->aggregator),
1190                                  priv->contact_id);
1191                 if (!dialog &&
1192                     priv->remote_id &&
1193                     priv->local_id)
1194                         dialog = create_temporary_contact_dialog (priv->remote_id,
1195                                                                   priv->local_id);
1196
1197                 if (dialog)
1198                         gtk_widget_show (dialog);
1199         }
1200                 break;
1201         case SELECTED_FOOTER:
1202                 if (priv->scroll_on_click) {
1203                         priv->scroll_on_click = FALSE;
1204                         priv->scroll_anim_id = g_timeout_add (SCROLL_PERIOD,
1205                                                               (GSourceFunc)scroll_anim_cb,
1206                                                               self);
1207                 }
1208                 else
1209 #ifndef DEBUG_LAYOUT
1210                         mark_as_read (self);
1211 #endif
1212                 break;
1213         default:;
1214         }
1215
1216         priv->active = SELECTED_NONE;
1217         gtk_widget_queue_draw (widget);
1218
1219         return TRUE;
1220 }
1221
1222 static gboolean
1223 leave_notify_event_cb (GtkWidget        *widget,
1224                        GdkEventCrossing *event,
1225                        ELHomeApplet     *self)
1226 {
1227         ELHomeAppletPrivate *priv = self->priv;
1228
1229         switch (priv->active) {
1230         case SELECTED_FOOTER:
1231                 stop_scroll_anim (priv);
1232                 /* fall down */
1233         case SELECTED_HEADER:
1234         case SELECTED_BODY:
1235                 gtk_widget_queue_draw (widget);
1236                 break;
1237         default:;
1238         }
1239
1240         priv->active = SELECTED_NONE;
1241         return FALSE;
1242 }
1243
1244 static void
1245 el_home_applet_init (ELHomeApplet *self)
1246 {
1247         ELHomeAppletPrivate *priv;
1248         GtkWidget *event_box;
1249         GtkWidget *hbox, *vbox, *align, *footer;
1250
1251         self->priv = EL_HOME_APPLET_GET_PRIVATE (self);
1252         priv = self->priv;
1253
1254         gtk_widget_set_app_paintable (GTK_WIDGET (self), TRUE);
1255
1256         priv->unread = gtk_label_new ("12");
1257         gtk_misc_set_alignment (GTK_MISC (priv->unread),
1258                                 0.0f,
1259                                 0.5f);
1260         hildon_helper_set_logical_font (priv->unread, "SmallSystemFont");
1261         /* gtk_widget_set_size_request (priv->unread, */
1262         /*                              -1, */
1263         /*                              HEADER_HEIGHT); */
1264 #if 0
1265         priv->icon = gtk_image_new_from_icon_name ("chat_unread_sms",
1266                                                    HILDON_ICON_SIZE_FINGER);
1267         gtk_misc_set_alignment (GTK_MISC (priv->icon),
1268                                 0.5f,
1269                                 0.5f);
1270 #endif
1271         priv->avatar = gtk_image_new ();
1272         gtk_misc_set_alignment (GTK_MISC (priv->avatar),
1273                                 0.5f,
1274                                 0.5f);
1275
1276         priv->sender = gtk_label_new ("asdf asdf asdf asdf asdf");
1277         gtk_misc_set_alignment (GTK_MISC (priv->sender),
1278                                 0.5f,
1279                                 0.55f);
1280         gtk_label_set_ellipsize (GTK_LABEL (priv->sender),
1281                                  PANGO_ELLIPSIZE_END);
1282         gtk_widget_set_name (priv->sender, "hildon-shadow-label");
1283         hildon_helper_set_logical_font (priv->sender, "SystemFont");
1284         gtk_widget_set_size_request (priv->sender,
1285                                      -1,
1286                                      HILDON_ICON_PIXEL_SIZE_THUMB);
1287
1288         priv->message = g_strdup ("One two three four five six seven eight nine ten");
1289
1290         /* TODO: l10n */
1291         priv->empty = gtk_label_new ("No new messages");
1292         gtk_widget_set_name (priv->empty, "hildon-shadow-label");
1293         GTK_WIDGET_SET_FLAGS (priv->empty, GTK_NO_SHOW_ALL);
1294
1295         priv->received = gtk_label_new ("aewf aewf aewf awef");
1296         gtk_misc_set_alignment (GTK_MISC (priv->received),
1297                                 1.0f,
1298                                 0.5f);
1299         hildon_helper_set_logical_font (priv->received, "SmallSystemFont");
1300         gtk_widget_set_name (priv->received, "hildon-shadow-label");
1301
1302
1303         priv->cut_message = gtk_label_new ("...");
1304         gtk_misc_set_alignment (GTK_MISC (priv->cut_message),
1305                                 0.5f,
1306                                 0.0f);
1307         hildon_helper_set_logical_font (priv->cut_message, "SmallSystemFont");
1308         gtk_widget_set_name (priv->cut_message, "hildon-shadow-label");
1309         GTK_WIDGET_SET_FLAGS (priv->cut_message, GTK_NO_SHOW_ALL);
1310
1311         hbox = gtk_hbox_new (FALSE, 0);
1312         /* gtk_box_pack_start (GTK_BOX (hbox), priv->icon, FALSE, FALSE, 0); */
1313         gtk_box_pack_start (GTK_BOX (hbox), priv->sender, TRUE, TRUE, 0);
1314         gtk_box_pack_start (GTK_BOX (hbox), priv->avatar, FALSE, FALSE, 0);
1315
1316         footer = gtk_hbox_new (FALSE, HILDON_MARGIN_DEFAULT);
1317         gtk_box_pack_start (GTK_BOX (footer), priv->unread, FALSE, FALSE, 0);
1318         gtk_box_pack_start (GTK_BOX (footer), priv->cut_message, TRUE, TRUE, 0);
1319         gtk_box_pack_end (GTK_BOX (footer), priv->received, FALSE, FALSE, 0);
1320
1321         vbox = gtk_vbox_new (FALSE, 0);
1322         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1323         gtk_box_pack_start (GTK_BOX (vbox), priv->empty, TRUE, TRUE, 0);
1324         gtk_box_pack_end (GTK_BOX (vbox), footer, FALSE, FALSE, 0);
1325
1326         align = gtk_alignment_new (0.5f, 0.0f, 1.0f, 1.0f);
1327         gtk_alignment_set_padding (GTK_ALIGNMENT (align),
1328                                    0, 0, HILDON_MARGIN_DEFAULT, HILDON_MARGIN_DEFAULT);
1329
1330         gtk_container_set_border_width (GTK_CONTAINER (vbox), HILDON_MARGIN_HALF);
1331
1332         event_box = gtk_event_box_new ();
1333         gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
1334         gtk_widget_set_size_request (event_box, BOX_WIDTH, BOX_HEIGHT);
1335
1336         gtk_container_add (GTK_CONTAINER (align), vbox);
1337         gtk_container_add (GTK_CONTAINER (event_box), align);
1338         gtk_container_add (GTK_CONTAINER (self), event_box);
1339
1340         g_signal_connect (event_box,
1341                           "button-press-event",
1342                           G_CALLBACK (button_press_event_cb),
1343                           self);
1344         g_signal_connect (event_box,
1345                           "button-release-event",
1346                           G_CALLBACK (button_release_event_cb),
1347                           self);
1348         g_signal_connect (event_box,
1349                           "leave-notify-event",
1350                           G_CALLBACK (leave_notify_event_cb),
1351                           self);
1352
1353         g_signal_connect (event_box,
1354                           "style-set",
1355                           G_CALLBACK (style_set_cb),
1356                           self);
1357         g_signal_connect (self,
1358                           "notify::is-on-current-desktop",
1359                           G_CALLBACK (notify_on_current_desktop),
1360                           self);
1361
1362         gtk_widget_show_all (GTK_WIDGET (event_box));
1363
1364 #ifndef DEBUG_LAYOUT
1365         priv->eventlogger = rtcom_el_new ();
1366         g_signal_connect (priv->eventlogger,
1367                           "new-event",
1368                           G_CALLBACK (new_event_cb),
1369                           self);
1370         g_signal_connect (priv->eventlogger,
1371                           "event-updated",
1372                           G_CALLBACK (new_event_cb),
1373                           self);
1374
1375         read_new_event (self);
1376
1377         osso_abook_init_with_name (PACKAGE, NULL);
1378 #endif
1379 }
1380
1381 static void
1382 el_home_applet_class_init (ELHomeAppletClass *klass)
1383 {
1384         GObjectClass *object_class = G_OBJECT_CLASS (klass);
1385         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
1386
1387         object_class->dispose = dispose;
1388         object_class->finalize = finalize;
1389         widget_class->expose_event = expose_event;
1390         widget_class->realize = el_home_applet_realize;
1391
1392         g_type_class_add_private (klass, sizeof (ELHomeAppletPrivate));
1393 }
1394