merge.c

/**
 * @file merge.c
 * Deals with the widgets of the merged window panes and menu bar
 *
 * @section LICENSE
 * Copyright (C) 2012 David Michael <fedora.dm0@gmail.com>
 *
 * This file is part of Window Merge.
 *
 * Window Merge 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 3 of the License, or (at your option)
 * any later version.
 *
 * Window Merge 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
 * Window Merge.  If not, see <http://www.gnu.org/licenses/>.
**/

#include "plugin.h"

#include <gtkblist.h>
#include <gtkconv.h>
#include <gtkimhtml.h>

#include <prefs.h>

#include <gdk/gdkkeysyms.h>

#include "window_merge.h"


/**
 * A callback for when the position of a GtkPaned slider changes
 *
 * This function is responsible for storing the width or height of the Buddy
 * List as a preference after the user changes it by dragging the slider.
 *
 * @param[in] gobject    Pointer to the GtkPaned structure that was resized
 * @param[in] pspec      Unused
 * @param[in] data       Pointer to the Buddy List that is a parent of gobject
**/
static void
notify_position_cb(GObject *gobject, U GParamSpec *pspec, gpointer data)
{
  PidginBuddyList *gtkblist;    /*< Buddy List window containing these panes */
  gint max_position;            /*< The "max-position" property of gobject   */
  gint size;                    /*< Current size of the Buddy List pane      */

  gtkblist = data;
  size = gtk_paned_get_position(GTK_PANED(gobject));

  /* If the Buddy List is not the first pane, invert the size preference. */
  if ( gtk_paned_get_child1(GTK_PANED(gobject)) != gtkblist->notebook ) {
    g_object_get(gobject, "max-position", &max_position, NULL);
    size = max_position - size;
  }

  /* Store this size as a user preference (depending on paned orientation). */
  if ( GTK_IS_VPANED(gobject) )
    purple_prefs_set_int(PREF_HEIGHT, size);
  else
    purple_prefs_set_int(PREF_WIDTH, size);
}


/**
 * A callback for when the total size of a GtkPaned changes
 *
 * This should be called after a new GtkPaned finds its parent and calculates
 * its "max-position" property.  It is only intended to be run on this single
 * occassion, so it removes itself on completion.  The call is used to set the
 * initial size of the Buddy List to the user's preference.
 *
 * @param[in] gobject    Pointer to the GtkPaned structure that was resized
 * @param[in] pspec      Unused
 * @param[in] data       Pointer to the Buddy List that is a parent of gobject
**/
static void
notify_max_position_cb(GObject *gobject, U GParamSpec *pspec, gpointer data)
{
  PidginBuddyList *gtkblist;    /*< Buddy List window containing these panes */
  gint max_position;            /*< The "max-position" property of gobject   */
  gint size;                    /*< Desired size of the Buddy List pane      */

  gtkblist = data;

  /* Fetch the user's preferred Buddy List size (depending on orientation). */
  if ( GTK_IS_VPANED(gobject) )
    size = purple_prefs_get_int(PREF_HEIGHT);
  else
    size = purple_prefs_get_int(PREF_WIDTH);

  /* If the Buddy List is not the first pane, invert the size preference. */
  if ( gtk_paned_get_child1(GTK_PANED(gobject)) != gtkblist->notebook ) {
    g_object_get(gobject, "max-position", &max_position, NULL);
    size = max_position - size;
  }

  /* Adjust the panes' slider to set the Buddy List to its desired size. */
  gtk_paned_set_position(GTK_PANED(gobject), size);

  /* Disconnect this callback.  This initial setting was only needed once. */
  g_object_disconnect(gobject, "any_signal",
                      G_CALLBACK(notify_max_position_cb), data, NULL);

  /* Now that system-induced slider changes are done, monitor user changes. */
  g_object_connect(gobject, "signal::notify::position",
                   G_CALLBACK(notify_position_cb), data, NULL);
}


/**
 * Pass a focus (in) event from one widget to another
 *
 * This is only used to trigger the signal handlers on the conversation window
 * for removing message notifications when the Buddy List window is focused.
 *
 * @param[in] widget     Unused
 * @param[in] event      Unused
 * @param[in] data       Pointer to the widget to receive the passed event
 * @return               Whether to stop processing other event handlers
**/
static gboolean
focus_in_event_cb(U GtkWidget *widget, U GdkEventFocus *event, gpointer data)
{
  GtkWidget *other_widget;      /*< Widget pretending to receive an event    */
  GdkWindow *window;            /*< Window of the widget receiving the event */
  GdkEvent *focus;              /*< New focus event for the specified widget */

  focus = gdk_event_new(GDK_FOCUS_CHANGE);
  other_widget = data;
  window = gtk_widget_get_window(other_widget);

  focus->focus_change.window = g_object_ref(window);
  focus->focus_change.send_event = TRUE;
  focus->focus_change.in = TRUE;

  gtk_widget_event(other_widget, focus);

  gdk_event_free(focus);

  return FALSE;
}


/**
 * Create a conversation window and merge it with the given Buddy List window
 *
 * This is the real core of the plugin right here.  It initializes the Buddy
 * List with a conversation window just like the project advertises.  See the
 * function pwm_split_conversation() to reverse this effect.
 *
 * @param[in] gtkblist   The Buddy List that will be able to show conversations
**/
void
pwm_merge_conversation(PidginBuddyList *gtkblist)
{
  PidginWindow *gtkconvwin;     /*< The mutilated conversations for gtkblist */
  GtkBindingSet *binding_set;   /*< The binding set of GtkIMHtml widgets     */

  /* Sanity check: If the Buddy List is already merged, don't mess with it. */
  if ( pwm_blist_get_convs(gtkblist) != NULL )
    return;

  binding_set = gtk_binding_set_by_class(g_type_class_ref(GTK_TYPE_IMHTML));
  gtkconvwin = pidgin_conv_window_new();

  /* Tie the Buddy List and conversation window instances together. */
  g_object_set_data(G_OBJECT(gtkblist->notebook), "pwm_convs", gtkconvwin);
  g_object_set_data(G_OBJECT(gtkconvwin->notebook), "pwm_blist", gtkblist);

  /* Backup the Buddy List window title for restoring it later. */
  pwm_store(gtkblist, "title",
            g_strdup(gtk_window_get_title(GTK_WINDOW(gtkblist->window))));

  /* Move the conversation notebook into the Buddy List window. */
  pwm_create_paned_layout(gtkblist, purple_prefs_get_string(PREF_SIDE));

  /* Display the instructions tab for new users. */
  pwm_init_dummy_conversation(gtkblist);
  pwm_show_dummy_conversation(gtkblist);

  /* Pass focus events from Buddy List to conversation window. */
  g_object_connect(G_OBJECT(gtkblist->window), "signal::focus-in-event",
                   G_CALLBACK(focus_in_event_cb), gtkconvwin->window, NULL);

  /* Point the conversation window structure at the Buddy List's window. */
  pwm_store(gtkblist, "conv_window", gtkconvwin->window);
  gtkconvwin->window = gtkblist->window;

  /* Block these "move-cursor" bindings for conversation event handlers. */
  /* XXX: These are skipped in any GtkIMHtml, not just the conversations. */
  /* XXX: Furthermore, there is no event to undo this effect. */
  gtk_binding_entry_skip(binding_set, GDK_Up,           GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_Down,         GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_Page_Up,      GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_Page_Down,    GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_KP_Page_Up,   GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_Tab,          GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_KP_Tab,       GDK_CONTROL_MASK);
  gtk_binding_entry_skip(binding_set, GDK_ISO_Left_Tab, GDK_CONTROL_MASK);
}


/**
 * Restore the Buddy List to its former glory by splitting off conversations
 *
 * This effectively will undo everything done by pwm_merge_conversation().  The
 * Buddy List should be returned to its original state, and any conversations
 * should be in a separate window.
 *
 * @param[in] gtkblist   The Buddy List that has had enough of this plugin
**/
void
pwm_split_conversation(PidginBuddyList *gtkblist)
{
  PidginWindow *gtkconvwin;     /*< Conversation window merged into gtkblist */
  GtkWidget *paned;             /*< The panes on the Buddy List window       */
  gchar *title;                 /*< Original title of the Buddy List window  */

  gtkconvwin = pwm_blist_get_convs(gtkblist);
  paned = pwm_fetch(gtkblist, "paned");
  title = pwm_fetch(gtkblist, "title");

  /* Ensure the conversation window's menu items are returned. */
  pwm_set_conv_menus_visible(gtkblist, FALSE);

  /* End the association between the Buddy List and its conversation window. */
  g_object_steal_data(G_OBJECT(gtkblist->notebook), "pwm_convs");
  g_object_steal_data(G_OBJECT(gtkconvwin->notebook), "pwm_blist");

  /* Point the conversation window's structure back to its original window. */
  gtkconvwin->window = pwm_fetch(gtkblist, "conv_window");
  pwm_clear(gtkblist, "conv_window");

  /* Stop passing focus events from Buddy List to conversation window. */
  g_object_disconnect(G_OBJECT(gtkblist->window), "any_signal",
                      G_CALLBACK(focus_in_event_cb), gtkconvwin->window, NULL);

  /* Restore the conversation window's notebook. */
  pwm_widget_replace(pwm_fetch(gtkblist, "placeholder"),
                     gtkconvwin->notebook, NULL);
  pwm_clear(gtkblist, "placeholder");

  /* Free the dummy conversation, and display the window if it survives. */
  pwm_free_dummy_conversation(gtkblist);
  if ( g_list_find(pidgin_conv_windows_get_list(), gtkconvwin) != NULL )
    pidgin_conv_window_show(gtkconvwin);

  /* Restore the Buddy List's original structure, and destroy the panes. */
  pwm_widget_replace(paned, gtkblist->notebook, NULL);
  pwm_clear(gtkblist, "paned");

  /* Restore the window title and icons from before conversations set them. */
  gtk_window_set_icon_list(GTK_WINDOW(gtkblist->window), NULL);
  gtk_window_set_title(GTK_WINDOW(gtkblist->window), title);
  g_free(title);
  pwm_clear(gtkblist, "title");
}


/**
 * Construct (or reconstruct when settings change) the window's paned layout
 *
 * It is worth noting that the string preferences only use the first character
 * to determine orientation since they are all unique (and it avoids calling
 * extra string functions).  The full strings are just for readable prefs.xml.
 *
 * @param[in] gtkblist   The Buddy List that needs a new paned window structure
 * @param[in] side       The pref where convs are placed relative to the blist
 *
 * @note This is structured to default to "right" on an invalid pref setting.
**/
void
pwm_create_paned_layout(PidginBuddyList *gtkblist, const char *side)
{
  PidginWindow *gtkconvwin;     /*< Conversation window merged into gtkblist */
  GtkWidget *old_paned;         /*< The existing paned layout, if it exists  */
  GtkWidget *paned;             /*< The new layout panes being created       */
  GtkWidget *placeholder;       /*< Marks the conv notebook's original spot  */
  GValue value = G_VALUE_INIT;  /*< For passing a property value to a widget */

  gtkconvwin = pwm_blist_get_convs(gtkblist);
  old_paned = pwm_fetch(gtkblist, "paned");

  /* Create the requested vertical or horizontal paned layout. */
  if ( side != NULL && (*side == 't' || *side == 'b') )
    paned = gtk_vpaned_new();
  else
    paned = gtk_hpaned_new();
  gtk_widget_show(paned);
  pwm_store(gtkblist, "paned", paned);

  /* When the size of the panes is determined, reset the Buddy List size. */
  g_object_connect(G_OBJECT(paned), "signal::notify::max-position",
                   G_CALLBACK(notify_max_position_cb), gtkblist, NULL);

  /* If the Buddy List is pristine, make the panes and replace its notebook. */
  if ( old_paned == NULL ) {
    placeholder = gtk_label_new(NULL);
    if ( side != NULL && (*side == 't' || *side == 'l') ) {
      pwm_widget_replace(gtkconvwin->notebook, placeholder, paned);
      pwm_widget_replace(gtkblist->notebook, paned, paned);
    } else {
      pwm_widget_replace(gtkblist->notebook, paned, paned);
      pwm_widget_replace(gtkconvwin->notebook, placeholder, paned);
    }
    pwm_store(gtkblist, "placeholder", placeholder);
  }

  /* If existing panes are being replaced, define the new layout and use it. */
  else {
    if ( side != NULL && (*side == 't' || *side == 'l') ) {
      gtk_widget_reparent(gtkconvwin->notebook, paned);
      gtk_widget_reparent(gtkblist->notebook, paned);
    } else {
      gtk_widget_reparent(gtkblist->notebook, paned);
      gtk_widget_reparent(gtkconvwin->notebook, paned);
    }
    pwm_widget_replace(old_paned, paned, NULL);
  }

  /* Make conversations resize with the window so the Buddy List is fixed. */
  g_value_init(&value, G_TYPE_BOOLEAN);
  g_value_set_boolean(&value, TRUE);
  gtk_container_child_set_property(GTK_CONTAINER(paned), gtkconvwin->notebook,
                                   "resize", &value);
  g_value_set_boolean(&value, FALSE);
  gtk_container_child_set_property(GTK_CONTAINER(paned), gtkblist->notebook,
                                   "resize", &value);
}


/**
 * Toggle the visibility of conversation window menu items
 *
 * The method of hiding the menu items is to reparent them back into their
 * original (still hidden) parent window.  This avoids conflicting with other
 * "hiding" methods used by plugins, such as widget sensitivity or visibility.
 *
 * When migrating to the Buddy List, left-justified items are inserted after
 * the last left-justified item.  Right-justified items are inserted before the
 * first right-justified item.  This appears to append conversation menu items
 * while keeping the Buddy List's notification icon on the far right.
 *
 * When migrating back to the conversation window, left-justified items are
 * prepended to all items.  Right-justified items are inserted before the first
 * right-justified item.  This gives the appearance of appending any newly
 * added menu items when they are all migrated to the Buddy List again.
 *
 * @param[in] gtkblist   The Buddy List whose menu needs adjusting
 * @param[in] visible    Whether the menu items are being shown or hidden
**/
void
pwm_set_conv_menus_visible(PidginBuddyList *gtkblist, gboolean visible)
{
  PidginWindow *gtkconvwin;     /*< Conversation window merged into gtkblist */
  GtkMenu *submenu;             /*< A submenu of a conversation menu item    */
  GtkContainer *from_menu;      /*< Menu bar of the window losing the items  */
  GtkContainer *to_menu;        /*< Menu bar of the window gaining the items */
  GtkWidget *blist_menu;        /*< The Buddy List menu bar                  */
  GtkWidget *convs_menu;        /*< The conversation window menu bar         */
  GtkWidget *item;              /*< A menu item widget being transferred     */
  GList *children;              /*< List of menu items in a given window     */
  GList *child;                 /*< A menu item in the list (iteration)      */
  GList *migrated_items;        /*< List of items added to the Buddy List    */
  gint index_left;              /*< Position to insert left-justified items  */
  gint index_right;             /*< Position to insert right-justified items */

  gtkconvwin = pwm_blist_get_convs(gtkblist);

  /* Sanity check: Only act on a merged Buddy List window. */
  if ( gtkconvwin == NULL )
    return;

  blist_menu = gtk_widget_get_parent(gtkblist->menutray);
  convs_menu = gtkconvwin->menu.menubar;
  from_menu = GTK_CONTAINER(visible ? convs_menu : blist_menu);
  to_menu   = GTK_CONTAINER(visible ? blist_menu : convs_menu);
  migrated_items = pwm_fetch(gtkblist, "conv_menus");

  /* XXX: Drop the "Send To" menu to avoid segfaults. */
  if ( visible && gtkconvwin->menu.send_to != NULL ) {
    gtk_widget_destroy(gtkconvwin->menu.send_to);
    gtkconvwin->menu.send_to = NULL;
  }

  /* Locate the position before the first right-aligned menu item. */
  index_right = 0;
  children = gtk_container_get_children(to_menu);
  for ( child = children; child != NULL; child = child->next )
    if ( gtk_menu_item_get_right_justified(GTK_MENU_ITEM(child->data)) )
      break;
    else
      index_right++;
  g_list_free(children);
  index_left = visible ? index_right : 0;

  /* Loop over each conversation menu item to move it to its destination. */
  children = visible ? gtk_container_get_children(from_menu) : migrated_items;
  for ( child = children; child != NULL; child = child->next ) {
    item = GTK_WIDGET(child->data);

    /* Reparent the item into the window based on existing justified items. */
    g_object_ref_sink(G_OBJECT(item));
    gtk_container_remove(from_menu, item);
    if ( gtk_menu_item_get_right_justified(GTK_MENU_ITEM(item)) )
      gtk_menu_shell_insert(GTK_MENU_SHELL(to_menu), item, index_right);
    else
      gtk_menu_shell_insert(GTK_MENU_SHELL(to_menu), item, index_left++);
    g_object_unref(G_OBJECT(item));
    index_right++;

    /* Register/Unregister its accelerator group with the Buddy List window. */
    submenu = GTK_MENU(gtk_menu_item_get_submenu(GTK_MENU_ITEM(item)));
    if ( visible )
      gtk_window_add_accel_group(GTK_WINDOW(gtkblist->window),
                                 gtk_menu_get_accel_group(submenu));
    else
      gtk_window_remove_accel_group(GTK_WINDOW(gtkblist->window),
                                    gtk_menu_get_accel_group(submenu));

    /* Add this menu item to the list for later restoration, if necessary. */
    if ( visible )
      migrated_items = g_list_append(migrated_items, child->data);
  }
  g_list_free(children);

  /* Update the stored pointer to the list of migrated items. */
  if ( visible )
    pwm_store(gtkblist, "conv_menus", migrated_items);
  else
    pwm_clear(gtkblist, "conv_menus");
}