callbacks.c

Linux下的飞鸽传书

/*
 *  Copyright (C) 2006 Takeharu KATO
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <glib.h>
#include <gconf/gconf-client.h>
#include "callbacks.h"
#include "interface.h"
#include "support.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <errno.h>
#include <libgnomevfs/gnome-vfs.h>
#include <libgnomevfs/gnome-vfs-utils.h>
#include <libgnomevfs/gnome-vfs-mime-handlers.h>
#include "common.h"

#define GLADE_HOOKUP_OBJECT(component,widget,name) \
  g_object_set_data_full (G_OBJECT (component), name, \
    gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref)

static GtkTargetEntry targetentries[] =
    {
      { "text/uri-list", 0, 0 },
    };


static int
get_group_index(GtkComboBox *combobox,const gchar *groupname,int *index) {
  GtkTreeModel *model;
  GtkTreeIter iter;
  gboolean valid;
  int count=0;

  if ( (!combobox) || (!groupname) || (!index) )
    return -EINVAL;

  g_assert(combobox);
  model=gtk_combo_box_get_model(combobox);

  g_assert(model);
  valid = gtk_tree_model_get_iter_first (model, &iter);
  while(valid) {
    gchar *str_data;

    gtk_tree_model_get (model, &iter, 
                          0, &str_data,
                          -1);
    dbg_out("group:%s\n",str_data);
    if (!strcmp(groupname,str_data)) {
      *index=count;
      dbg_out("find:%s(%d)\n",str_data,*index);
      g_free(str_data);
      return 0;
    }
    g_free(str_data);
    valid = gtk_tree_model_iter_next (model, &iter);
    ++count;
  }

  return -ESRCH;
}
static int
get_current_group_index(GtkComboBox *combobox) {
  int rc;
  int index=0;
  gchar *current_group;

  g_assert(combobox);

  current_group=(gchar *)hostinfo_refer_group_name();
  rc=get_group_index(combobox,current_group,&index);

  return index;
}
static int
updateConfigWindowGroups(GtkWidget *comboEntry) {
  GtkTreeModel *model;
  GtkTreePath *path;
  GtkTreeIter iter;
  gchar *active_text;
  int group_index=0;
  int rc;

  model=gtk_combo_box_get_model(GTK_COMBO_BOX(comboEntry));
  if (!model)
    return -EINVAL;

  path=gtk_tree_path_new_first ();
  g_assert(path);

  if (gtk_tree_model_get_iter(model,&iter,path)) {
    while(gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
      dbg_out("Remove group\n");
  }
  gtk_tree_path_free (path);
  userdb_update_group_list(GTK_COMBO_BOX(comboEntry));

  active_text=gtk_combo_box_get_active_text(GTK_COMBO_BOX(comboEntry));
  if ( (active_text) &&   ((strlen(active_text))>0)) {
    rc=get_group_index(GTK_COMBO_BOX(comboEntry),active_text,&group_index);
    if (rc<0)
      gtk_combo_box_append_text (GTK_COMBO_BOX(comboEntry),active_text);
    else
      gtk_combo_box_set_active (GTK_COMBO_BOX(comboEntry),group_index);
  }

  if (active_text)
    g_free(active_text);

  return 0;
}
static void
sendmessage_get_attachment_part(long pktno,GtkWidget *editor,const char **ext_part){
  attach_file_block_t *afcb;
  GtkTreeIter  iter;
  GtkWidget    *view;
  GtkTreeModel *model;
  gboolean valid;
  gchar *string;
  int count;
  
  dbg_out("here\n");

  g_assert(ext_part);
  g_assert(*ext_part == NULL);

  if (create_attach_file_block(&afcb))
    return;

  view=lookup_widget(editor,"attachedFilesView");
  g_assert(view);

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  g_assert(model);
  count=0;
  valid = gtk_tree_model_get_iter_first (model, &iter);
  while(valid) {
      gchar *filepath;

      gtk_tree_model_get (model, &iter, 
                          0, &filepath,
                          -1);
      dbg_out("filepath:%s\n",filepath);
      add_attach_file(afcb,filepath);
      g_free(filepath);
      ++count;
      valid = gtk_tree_model_iter_next (model, &iter);
  }
  if ( (count > 0) && (!get_attach_file_extention(afcb,(const gchar **)&string)) ){
    add_upload_queue(pktno,afcb);
    dbg_out("Attach file string:%s\n",string);
    *ext_part=string;  
  }
}
static void
do_send(GtkTreeModel *model,
	       GtkTreePath *path,
	       GtkTreeIter *iter,
	       gpointer data){
  send_info_t *info;
  gchar *ipaddr;
  int pkt_no;
  int rc;
  GtkWidget *attachment_editor;
  gchar *ext_part=NULL;
  int lflags;

  info=(send_info_t *)data;
  gtk_tree_model_get (model, iter, 
		      USER_VIEW_IPADDR_ID, &ipaddr,
		      -1);

  pkt_no=ipmsg_get_pkt_no();
  lflags=info->flags;
  dbg_out("Send to %s Flags[%x] from ui\n",ipaddr,lflags);

  if ( lflags & IPMSG_FILEATTACHOPT){
    /*
     *アタッチメント
     */
    attachment_editor=info->attachment_editor;
    if (attachment_editor) {
      dbg_out("This message has attachment\n");
      ext_part=NULL;
      sendmessage_get_attachment_part(pkt_no,GTK_WIDGET(attachment_editor),(const char **)&ext_part);
      if (!ext_part) {
	lflags &= ~IPMSG_FILEATTACHOPT;
      }
    }
  }
  if ( lflags & IPMSG_FILEATTACHOPT){
    rc=ipmsg_send_send_msg(udp_con,ipaddr,lflags,pkt_no,info->msg,ext_part);
    if (!rc) {
      ref_attach_file_block(pkt_no,ipaddr);
    }
  } else {
    rc=ipmsg_send_send_msg(udp_con,ipaddr,lflags,pkt_no,info->msg,NULL);
  }
  if (rc)
    ipmsg_err_dialog(_("Can not send message to %s pktno=%d"),ipaddr,pkt_no);
  if (ext_part)
    g_free(ext_part);
  g_free(ipaddr);
}
static int
has_dupulicated_string_in_cell(const char *string,GtkTreeView *treeview){
  GtkTreeModel *model;
  GtkTreeIter iter;
  gboolean valid;
  int rc;

  g_assert(treeview);
  if (!string)
    return -EINVAL;

  rc=-ESRCH;
  model = gtk_tree_view_get_model(treeview);
  for(valid = gtk_tree_model_get_iter_first (model, &iter);
      valid;
      valid = gtk_tree_model_iter_next (model, &iter)) {
	gchar *str_data;
	gtk_tree_model_get (model, &iter, 
                          0, &str_data,
                          -1);
	if (!strcmp(string,str_data)) {
	  dbg_out("Already exist:%s\n",str_data);
	  g_free(str_data);
	  rc=0;
	  break;
	}
	g_free(str_data);
  }
  return rc;
}
static void
onBroadcastSelectionChanged (GtkTreeSelection *sel, GtkListStore *liststore)
{
  GtkTreeIter  selected_row;
  GtkWidget    *view;
  GtkWidget    *remove_btn;
  
  view=GTK_WIDGET(gtk_tree_selection_get_tree_view(sel));
  g_assert(view);
  remove_btn=lookup_widget(GTK_WIDGET(view),"configRemoveBcastBtn");
  g_assert(remove_btn);
  g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);

  if (gtk_tree_selection_get_selected(sel, NULL, &selected_row))
    {
      gtk_widget_set_sensitive(remove_btn, TRUE);
    }
  else
    {
      gtk_widget_set_sensitive(remove_btn, FALSE);
    }
}

void
on_app1_drag_data_received             (GtkWidget       *widget,
                                        GdkDragContext  *drag_context,
                                        gint             x,
                                        gint             y,
                                        GtkSelectionData *data,
                                        guint            info,
                                        guint            time,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}


gboolean
on_app1_drag_drop                      (GtkWidget       *widget,
                                        GdkDragContext  *drag_context,
                                        gint             x,
                                        gint             y,
                                        guint            time,
                                        gpointer         user_data)
{
  dbg_out("here\n");
  return FALSE;
}


gboolean
on_app1_destroy_event                  (GtkWidget       *widget,
                                        GdkEvent        *event,
                                        gpointer         user_data)
{
  dbg_out("here\n");
  return FALSE;
}


void
on_app1_destroy                        (GtkObject       *object,
                                        gpointer         user_data)
{
  GtkWidget *window;
  GtkWidget *attachment_editor;

  dbg_out("here\n");

  window=lookup_widget(GTK_WIDGET(object),"messageWindow");
  g_assert(window);

  attachment_editor = (GtkWidget*) g_object_get_data (G_OBJECT (object),
						      "attach_win");
  if (attachment_editor) 
    gtk_widget_destroy (attachment_editor);
  else
    dbg_out("No attachment editor\n");

  userdb_remove_waiter_window(window);
}


void
on_new1_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}


/* notice: This function may be called from applt, so we should not use
 * menuitem argument.
 */
void
on_preferences1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  GtkWidget *configWindow;
  GtkTreeView *broadcasts;
  GtkCellRenderer    *renderer;
  GtkTreeViewColumn  *col;
  GtkTreeSelection   *sel;
  GtkListStore       *liststore;

  dbg_out("here\n");
  configWindow=create_configWindow1 ();
  if (!configWindow) 
    return;

  broadcasts=GTK_TREE_VIEW(lookup_widget(configWindow,"treeview4"));
  g_assert(broadcasts);

  renderer = gtk_cell_renderer_text_new();
  if (!renderer)
    goto free_window;

  col = gtk_tree_view_column_new();
  if (!col)
    goto free_renderer;

  liststore = gtk_list_store_new(1, G_TYPE_STRING);
  if (!liststore)
    goto free_col;

  gtk_tree_view_set_model(GTK_TREE_VIEW(broadcasts), GTK_TREE_MODEL(liststore));
  g_object_unref(liststore);
  gtk_tree_view_column_pack_start(col, renderer, TRUE);
  gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
  gtk_tree_view_column_set_title(col, _("Broad cast addresses"));

  gtk_tree_view_append_column(GTK_TREE_VIEW(broadcasts), col);

  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(broadcasts));
  gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
  g_signal_connect(sel, "changed", 
		   G_CALLBACK(onBroadcastSelectionChanged),
		   liststore);
  

  gtk_widget_show (configWindow);

  return;

 free_window:
  gtk_widget_destroy(GTK_WIDGET(configWindow));
 free_col:
  gtk_object_destroy(GTK_OBJECT(col));
 free_renderer:
  gtk_object_destroy(GTK_OBJECT(renderer));
  return;
}

void
on_update2_activate                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  dbg_out("here\n");
  ipmsg_update_ui_user_list();
}


void
on_about1_activate                     (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ipmsg_show_about_dialog();
}


void
on_sendBtn_released                    (GtkButton       *button,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}


void
on_sendBtn_pressed                     (GtkButton       *button,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}

void
on_configOpenCheckChkBtn_toggled       (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}


void
on_configNonPopupCheckBtn_toggled      (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}


void
on_configNoSoundCheckBtn_toggled       (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  dbg_out("here\n");
}