app.c

GNOME下的短信息发送中心

			     (num->sent == 0)) && (num->sent != 2)) {
				
				GSmsMessage *msg = g_new0(GSmsMessage, 1);
				msg->text = text;
				msg->num = g_strdup(num->phone_number);
				msg->user_data = num;
				*all = g_slist_append(*all, msg);
			}

		} else if(num->numbers != NULL) {
			app_send_sms_to(all, num->numbers, sms, text);
		} else {
			g_assert_not_reached();
		}

		numbers = g_slist_next(numbers);
	}
}


static gint
open_fail_dialog (gchar *num) 
{
	GtkWidget *dialog, *checkbutton, *hbox;
	gchar *message;
	gint sel_button;
	
	message = g_strdup_printf("Try to send messsage to %s again ?",num);
	dialog = gnome_question_dialog_modal_parented(message, NULL, NULL, 
						      GTK_WINDOW(appwidgets.app));
	hbox = gtk_hbox_new(FALSE,0);
	checkbutton = gtk_check_button_new_with_label("Do the same for the rest");
	gtk_signal_connect(GTK_OBJECT(checkbutton),
			   "toggled",
			   GTK_SIGNAL_FUNC(forall_button_cb),
			   NULL);
	
	gtk_box_pack_start(GTK_BOX(hbox), checkbutton, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dialog)->vbox),hbox,FALSE, 
			   FALSE, 0);
	
	gtk_widget_show_all(dialog);
	sel_button = gnome_dialog_run_and_close (GNOME_DIALOG(dialog));
								
	g_free(message);
	return sel_button;

}

static void 
to_entry_remove(GtkWidget * entry)
{
	GtkWidget *hbox;

	hbox = (GtkWidget *) gtk_object_get_user_data(GTK_OBJECT(entry));
	if (hbox != NULL) {
		gtk_widget_destroy(hbox);
		appwidgets.recipients = 
			g_list_remove(appwidgets.recipients, entry);
	}

}

/* remove empty GtkEntrie fields from the receptients */
static void
to_entry_cleanup () 
{

	GList *recp, *tmp;
	
	recp=g_list_last(appwidgets.recipients);

	while(recp != NULL) {

		tmp = recp;
		recp = g_list_previous(recp);
		if(recp == NULL)
			gtk_entry_set_text(GTK_ENTRY(tmp->data),"");
		else
			to_entry_remove(tmp->data);
	}
	
	gtk_editable_delete_text(GTK_EDITABLE(appwidgets.text),0,-1);
	
}



static void 
ctree_add_sms_item  (GSList *num, GtkCTreeNode *node) {

	gchar *dummy[] = { NULL, "" };
	GtkCTreeNode *node_next;

	while(num != NULL) {
		
		GSmsNumber *number = num->data;

		if (number->phone_number != NULL) {
 
			if (number->name == NULL)
				dummy[0]=number->phone_number;
			else
				dummy[0]=number->name;

			node_next = gtk_ctree_insert_node(GTK_CTREE
							  (appwidgets.tree), 
							  node, NULL, dummy, 
							  0, NULL, NULL, NULL, 
							  NULL, TRUE, FALSE);

			gtk_ctree_node_set_row_data(GTK_CTREE(appwidgets.tree),
					    node_next, number);
		}

		else {
			dummy[0]=number->name;
			
			node_next = gtk_ctree_insert_node(GTK_CTREE
							  (appwidgets.tree), 
							  node, NULL, dummy,
							  0, NULL, NULL, NULL, 
							  NULL, FALSE, FALSE);
		      	
			gtk_ctree_node_set_row_data(GTK_CTREE(appwidgets.tree),
					    node_next, number);

			ctree_add_sms_item (number->numbers, node_next);
			
		}

      		num = g_slist_next(num);
	}
}
	


static void 
ctree_add_sms(Gsms *sms) {
	GSList *num_e;
	gchar *mess[] = { "Message", "" };
	GtkCTreeNode *main_node;
	
	num_e = sms->numbers;

	main_node=gtk_ctree_insert_node(GTK_CTREE(appwidgets.tree), NULL, 
					NULL, mess, 0, NULL, NULL,
					NULL, NULL, FALSE, TRUE);
	gtk_ctree_node_set_row_data(GTK_CTREE(appwidgets.tree),
				    main_node, sms);

	ctree_add_sms_item (num_e, main_node);

}


static GSList*
remove_numbers (GSList *numbers , gboolean remove) 
{
	GSList *num_ptr = numbers, *new_numbers=numbers;

	/* Clean up list (GSmsNumber*) recursiv */
	while (num_ptr != NULL) {
		GSmsNumber *num = num_ptr->data;
		GtkCTreeNode *node;

		num_ptr=g_slist_next(num_ptr);

		if (num->phone_number != NULL ) {
			node=gtk_ctree_find_by_row_data(
				GTK_CTREE(appwidgets.tree), NULL, num);

			if ( remove || num->sent > 0 ) {
				if (node != NULL ) 
					gtk_ctree_remove_node(
						GTK_CTREE(appwidgets.tree), 
						node);	
				g_free(num->name);
				g_free(num->phone_number);
				new_numbers=g_slist_remove(new_numbers, num);
				g_free(num);
			}
		} else new_numbers = remove_numbers(num->numbers, remove);
	}

	return new_numbers;
}

static void 
queue_clean_up (gboolean remove) 
{
	GList *sms_ptr=sms_queue;

	while (sms_ptr != NULL) {
		GSList *numbers;
		Gsms *new_sms = sms_ptr->data;
		GtkCTreeNode *node;
		
		numbers = remove_numbers(new_sms->numbers, remove);
		new_sms->numbers=numbers;

		if (new_sms->numbers == NULL) {
			node = gtk_ctree_find_by_row_data(
				GTK_CTREE(appwidgets.tree), NULL, new_sms);
			gtk_ctree_remove_node(GTK_CTREE(appwidgets.tree),node);

			sms_ptr = g_list_next(sms_ptr);
			sms_queue = g_list_remove(sms_queue, new_sms);
			g_free(new_sms);
		} else {
			sms_ptr->data = new_sms;
			sms_ptr=g_list_next(sms_ptr);
		}
	}
}



/**************************************************************************/
/***************************** callbacks **********************************/
/**************************************************************************/

static gint 
app_close_down_cb(GtkWidget * window, GdkEventAny * e, gpointer data)
{
	sms_app_close(window);

	/* Prevent the window's destruction, since we destroyed it 
	 * ourselves with sms_app_close()
	 */
	return TRUE;
}

static void 
text_changed_cb(GtkWidget * text, gpointer data)
{
	gint n;
	gchar mess[30];
	GtkWidget *label;

	n = gtk_text_get_length(GTK_TEXT(text));
	label = (GtkWidget *) data;

	/* Check for count of chars */
	if (n > SMSLEN) {
		gtk_text_backward_delete(GTK_TEXT(text), n - SMSLEN);
		gnome_appbar_set_status(appwidgets.appbar,
					_("Maximum of chars for SMS reached"));
	} else {
		sprintf(mess, _("Remaining chars %d of %d"), SMSLEN - n,
			SMSLEN);
		gnome_appbar_set_status(appwidgets.appbar, mess);
	}

}

static void 
to_entry_changed_cb(GtkWidget * entry, gpointer data)
{
	GtkWidget *last=NULL;
	gchar *text;

	text = gtk_entry_get_text(GTK_ENTRY(entry));

	/* Remove an entry */
	if (*text == 0) {
		last=(GtkWidget*) g_list_previous(
			g_list_find(appwidgets.recipients,entry)
			)->data;
		gtk_widget_grab_focus(last);

		to_entry_remove(entry);		
	}
}

static void 
to_entry_activate_cb(GtkWidget * entry, gpointer data)
{
	GtkWidget *hbox, *button, *new_entry, *vbox;

	vbox = (GtkWidget *) data;

	button = gtk_button_new_with_label("TO:");
	new_entry = gtk_entry_new();
	hbox = gtk_hbox_new(FALSE, 0);
	gtk_signal_connect(GTK_OBJECT(button),
			   "clicked",
			   GTK_SIGNAL_FUNC(to_button_clicked_cb),
			   new_entry);

	/* Add a new entry */
	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 5);
	gtk_container_add(GTK_CONTAINER(hbox), new_entry);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
	gtk_widget_show_all(vbox);

	gtk_tooltips_set_tip(appwidgets.rcp_tooltip, new_entry,
                             "Enter Number like [phone]", NULL);
	gtk_signal_connect(GTK_OBJECT(new_entry), "activate",
			   GTK_SIGNAL_FUNC(to_entry_activate_cb), 
			   (gpointer) vbox);


	gtk_signal_connect(GTK_OBJECT(new_entry), "changed",
			   GTK_SIGNAL_FUNC(to_entry_changed_cb),
			   NULL);

	gtk_widget_grab_focus(new_entry);
	appwidgets.recipients=g_list_append(appwidgets.recipients, new_entry);
	gtk_object_set_user_data(GTK_OBJECT(new_entry), (gpointer) hbox);

	gtk_adjustment_set_value(
		GTK_ADJUSTMENT(appwidgets.rcp_adj),
		GTK_WIDGET(appwidgets.recipients->data)->requisition.height + 
		appwidgets.rcp_adj->upper - appwidgets.rcp_adj->page_size);
}

static void 
tree_clicked_cb (GtkWidget *ctree, GdkEventButton *event, gpointer user_data)
{
	gboolean sel;

	if ((event->type==GDK_BUTTON_PRESS) && (event->button == 3)) {
		GList* list = GTK_MENU_SHELL(appwidgets.popup)->children;

		if (sel_node == NULL) 
			sel = FALSE;
		else 
			sel = TRUE;
    
      		gtk_widget_set_sensitive ( GTK_WIDGET(list->data), sel);
		list = list->next;
		gtk_widget_set_sensitive ( GTK_WIDGET(list->data), sel);

		gtk_menu_popup (GTK_MENU(appwidgets.popup), NULL, NULL, NULL,
                                NULL, event->button, event->time);
	}
}

static void 
tree_select_item_cb (GtkCTree *ctree, GList *node, gint column,
			     gpointer user_data) {
	sel_node =  GTK_CTREE_NODE(node);
	  
}

static void 
tree_unselect_item_cb (GtkCTree *ctree, GList *node, gint column,
			     gpointer user_data) {
	sel_node =  NULL;
	  
}

/* this callback gets called from the functions sendsms.c after every sms
 * sent and after the last sms has been sent - see sendsms.h for more info */
static void
sms_send_cb(GSmsMessage *message, GSList *messages)
{
	static GdkColor col_red   = {0, 0xbbbb, 0, 0};
	static GdkColor col_green = {0, 0, 0xbbbb, 0};


	if(message !=NULL) {
		gint count, length;
		gchar *buf;

		GSmsMessage * msg = message;
		GtkCTreeNode *node;

		length = GPOINTER_TO_INT(gtk_object_get_user_data(
			GTK_OBJECT(appwidgets.sd_progress)));
		count = GPOINTER_TO_INT(gtk_object_get_user_data(
			GTK_OBJECT(appwidgets.sd_label)));
		gtk_object_set_user_data(GTK_OBJECT(appwidgets.sd_label),
					 GINT_TO_POINTER (++count) );
		buf = g_strdup_printf(_("Message %d of %d sent"), 
				      count, length);


		gdk_threads_enter();
		gtk_label_set_text(GTK_LABEL(appwidgets.sd_label), buf);
		gtk_label_set_text(GTK_LABEL(appwidgets.sd_label_num), 
				   msg->num);
		gtk_progress_set_percentage(
			GTK_PROGRESS(appwidgets.sd_progress),
			((gfloat) count) / ((gfloat) length));
		gtk_widget_queue_draw(appwidgets.sd_label);
		gtk_widget_queue_draw(appwidgets.sd_label_num);
		gtk_widget_queue_draw(appwidgets.sd_progress);
		gdk_threads_leave();
		g_free(buf);

		g_free(msg->num);

		gdk_threads_enter();

		node = gtk_ctree_find_by_row_data(GTK_CTREE(appwidgets.tree), 
						  NULL, msg->user_data);
		if (node != NULL) {
			GSmsNumber *q_ptr=(GSmsNumber*)msg->user_data; 
			if(message->sent > 0) {
				gtk_ctree_node_set_text(
					GTK_CTREE(appwidgets.tree), 
					node, 1, "Sent");
				gtk_ctree_node_set_foreground(
					GTK_CTREE(appwidgets.tree),
					node, & col_green);
				q_ptr->sent=1;
			} else if(message->sent < 0) {
				gtk_ctree_node_set_text(
					GTK_CTREE(appwidgets.tree), 
					node, 1, "Faild");
				gtk_ctree_node_set_foreground(
					GTK_CTREE(appwidgets.tree),
					node, & col_red);
				q_ptr->sent=-1;
			} else
				gtk_ctree_node_set_text(
					GTK_CTREE(appwidgets.tree), 
					node, 1, "Not Sent");
			gtk_widget_queue_draw(appwidgets.tree);
		}

		gdk_threads_leave();
	} else if(messages !=NULL) { /* All messages sent */
		GSmsMessage * msg = messages->data;

		/* update the send dialog widgets */
		gdk_threads_enter();
		gtk_label_set_text(GTK_LABEL(appwidgets.sd_label_num), 
				   _("All messages sent"));
		gtk_label_set_text(GTK_LABEL(appwidgets.sd_button_label), 
				   _("OK"));
		gtk_widget_queue_draw(appwidgets.sd_label_num);
		gtk_widget_queue_draw(appwidgets.sd_button_label);
		gdk_threads_leave();

		appwidgets.sd_done = TRUE;

		/* init autoclose of send dialog*/
		send_dialog_timer_cb(GINT_TO_POINTER(10));
		appwidgets.sd_timer_id = g_timeout_add(1000, 
						       send_dialog_timer_cb, 
						       GINT_TO_POINTER(0));

		g_free(msg->text); /* free the message text */

		/* free the memory used by the GSList of by send_sms */
		while(messages != NULL) {
			GSList *m = messages;
			messages = g_slist_remove_link(messages, m);
			g_free(m->data);
			g_slist_free_1(m);
		}
	} else g_assert_not_reached();
}

static void 
to_button_clicked_cb(GtkWidget * button, gpointer data) 
{
	abook_insert_entry(GTK_WIDGET(data));
}

/**************************************************************************/
/***************************** send dialog ********************************/
/**************************************************************************/

GtkWidget *
send_dialog_new(void)
{
	GtkWidget *table, *button;
	GtkWidget *window = gtk_window_new(GTK_WINDOW_DIALOG);
	GdkImlibImage *animpix;

	appwidgets.sd_done = FALSE;
	appwidgets.sd_timer_id = -1;

  	gtk_window_set_transient_for(GTK_WINDOW(window), 
				     GTK_WINDOW(appwidgets.app));

	gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE);

	table = gtk_table_new(4, 2, FALSE);

	appwidgets.sd_label = gtk_label_new(_("Sending messages..."));
	appwidgets.sd_label_num = gtk_label_new("");
	gtk_object_set_user_data(GTK_OBJECT(appwidgets.sd_label),
				 GINT_TO_POINTER (0) );
	appwidgets.sd_progress = gtk_progress_bar_new();

	/* load animation - TODO: howdo i free animpix !?!?! */
  	animpix = gdk_imlib_create_image_from_xpm_data(gsms_send_anim_xpm);
	appwidgets.sd_anim = gnome_animator_new_with_size(75,75);
	gnome_animator_set_loop_type (GNOME_ANIMATOR(appwidgets.sd_anim),
				      GNOME_ANIMATOR_LOOP_RESTART);
	gnome_animator_append_frames_from_imlib(
		GNOME_ANIMATOR(appwidgets.sd_anim), animpix, 0, 0, 150, 75);

	appwidgets.sd_button_label = gtk_label_new(_("Cancel"));
	button = gtk_button_new();
	gtk_container_add(GTK_CONTAINER(button), appwidgets.sd_button_label);

	gtk_table_attach(GTK_TABLE(table), appwidgets.sd_label_num, 
			 1, 2, 0, 1, GTK_FILL, GTK_SHRINK, 5, 0);
	gtk_table_attach(GTK_TABLE(table), appwidgets.sd_progress, 1, 2, 1, 2, 
			 GTK_FILL, GTK_SHRINK, 5, 0);
	gtk_table_attach(GTK_TABLE(table), appwidgets.sd_label, 1, 2, 2, 3, 
			 GTK_FILL, GTK_SHRINK, 5, 0);
	gtk_table_attach(GTK_TABLE(table), button, 1, 2, 3, 4, 
			 GTK_SHRINK, GTK_SHRINK, 10, 5);
  	gtk_table_attach(GTK_TABLE(table), appwidgets.sd_anim, 0, 1, 0, 4, 
  			 GTK_SHRINK, GTK_SHRINK, 10, 10);

	gtk_container_add(GTK_CONTAINER(window), table);

  	gtk_signal_connect(GTK_OBJECT(window),
			   "delete_event",
			   GTK_SIGNAL_FUNC(send_dialog_close_cb), NULL);

	gtk_widget_show_all(window);

	gtk_signal_connect(GTK_OBJECT(button), "clicked",
			   GTK_SIGNAL_FUNC(send_dialog_button_cb), NULL);


	gnome_animator_start(GNOME_ANIMATOR(appwidgets.sd_anim));

	return window;
}


static gint 
send_dialog_close_cb(GtkWidget * window, GdkEventAny * e, gpointer data)
{
	puts("send_dialog_close_cb called"); fflush(stdout);
	if(appwidgets.sd_done) {
		gnome_animator_stop(GNOME_ANIMATOR(appwidgets.sd_anim));
		appwidgets.sd_window = NULL;
		return FALSE;
	} return TRUE;
}

/* we cant destroy the widget from the callback - so do it this way */
/* TODO: write to the mailing-list if this is ok                    */
static gboolean
send_dialog_idle_destroy(gpointer data) {
	gnome_animator_stop(GNOME_ANIMATOR(appwidgets.sd_anim));
	gtk_widget_destroy(appwidgets.sd_window);
	appwidgets.sd_window = NULL;

	return FALSE;
}

void 
send_dialog_button_cb(GtkButton *button,  gpointer user_data)
{
	if(! appwidgets.sd_done)
		send_sms_end(appwidgets.send_sms_h, TRUE);
	else
		g_source_remove(appwidgets.sd_timer_id);
	g_idle_add(send_dialog_idle_destroy, NULL);
}

/* auto close after 10s */
gboolean
send_dialog_timer_cb(gpointer data)
{
	static gint counter;
	gchar *buf;
	
	if(GPOINTER_TO_INT(data) != 0)
		counter = GPOINTER_TO_INT(data);
	
	if(--counter < 0)
		return send_dialog_idle_destroy(NULL); /* close the window */

	buf = g_strdup_printf(_("Autoclose in %d seconds"), counter+1);
	gtk_label_set_text(GTK_LABEL(appwidgets.sd_label), buf);
	gtk_widget_queue_draw(appwidgets.sd_label);
	g_free(buf);

	return TRUE;
}

static void 
forall_button_cb (GtkToggleButton *togglebutton, gpointer user_data) {

	forall = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(togglebutton));
}