home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / yagirc-0.51.tar.gz / yagirc-0.51.tar / yagirc-0.51 / gui_join.c < prev    next >
C/C++ Source or Header  |  1998-05-09  |  11KB  |  378 lines
  1. /*
  2.  
  3.  gui_join.c : Join channel dialog
  4.  
  5.     Copyright (C) 1998 Timo Sirainen
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <string.h>
  24.  
  25. #include <glib.h>
  26.  
  27. #include "os.h"
  28. #include "gui.h"
  29. #include "irc.h"
  30. #include "commands.h"
  31.  
  32. enum
  33. {
  34.     ACTION_NONE,
  35.     ACTION_ADD,
  36.     ACTION_EDIT,
  37. };
  38.  
  39. GList *joinlist;
  40.  
  41. static GtkWidget *joindlg = NULL;
  42. static GList *jointemp;
  43. static int doubleclick;
  44.  
  45. /* add new entry */
  46. static void add_entry(GtkList *list, char *chan)
  47. {
  48.     GtkWidget *li;
  49.     GList *glist;
  50.     int pos;
  51.  
  52.     while (*chan == ' ') chan++;
  53.     if (*chan == '\0') return;
  54.  
  55.     if (*chan == '#' || *chan == '&')
  56.         chan = g_strdup(chan);
  57.     else
  58.     {
  59.         char *tmp;
  60.  
  61.         tmp = g_malloc(strlen(chan)+2);
  62.         sprintf(tmp, "#%s", chan);
  63.         chan = tmp;
  64.     }
  65.  
  66.     li = gtk_list_item_new_with_label(chan);
  67.     gtk_object_set_data(GTK_OBJECT(li), "channel", g_strdup(chan));
  68.     gtk_widget_show(li);
  69.  
  70.     /* sort insert */
  71.     glist = GTK_LIST(list)->children;
  72.     for (pos = 0; glist != NULL; pos++, glist = glist->next)
  73.     {
  74.         char *data;
  75.  
  76.         data = gtk_object_get_data(GTK_OBJECT(glist->data), "channel");
  77.         if (strcasecmp(data, chan) > 0) break;
  78.     }
  79.  
  80.     glist = g_list_append(NULL, li);
  81.     gtk_list_insert_items(list, glist, pos);
  82.     jointemp = g_list_insert(jointemp, g_strdup(chan), pos);
  83.  
  84.     gtk_list_select_child(list, li);
  85. }
  86.  
  87. /* signal: add button pressed */
  88. static void sig_add_join(GtkWidget *widget, GtkList *list)
  89. {
  90.     GtkEntry *entry;
  91.  
  92.     g_return_if_fail(list != NULL);
  93.  
  94.     entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  95.  
  96.     gtk_entry_set_text(entry, "");
  97.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_ADD);
  98.  
  99.     gtk_widget_grab_focus(GTK_WIDGET(entry));
  100. }
  101.  
  102. /* signal: edit button pressed */
  103. static void sig_edit_join(GtkWidget *widget, GtkList *list)
  104. {
  105.     GtkEntry *entry;
  106.     char *data;
  107.  
  108.     g_return_if_fail(list != NULL);
  109.     if (list->selection == NULL) return;
  110.  
  111.     data = gtk_object_get_data(GTK_OBJECT(list->selection->data), "channel");
  112.     entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  113.  
  114.     gtk_entry_set_text(entry, data);
  115.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_EDIT);
  116.  
  117.     gtk_widget_grab_focus(GTK_WIDGET(entry));
  118. }
  119.  
  120. /* signal: delete button pressed */
  121. static void sig_delete_join(GtkWidget *widget, GtkList *list)
  122. {
  123.     GList *glist;
  124.     int pos;
  125.  
  126.     g_return_if_fail(list != NULL);
  127.     if (list->selection == NULL) return;
  128.  
  129.     /* remove from join list */
  130.     pos = gtk_list_child_position(list, list->selection->data);
  131.     glist = g_list_nth(jointemp, pos);
  132.     g_free(glist->data);
  133.     jointemp = g_list_remove_link(jointemp, glist);
  134.  
  135.     /* remove from gtk list */
  136.     g_free(gtk_object_get_data(GTK_OBJECT(list->selection->data), "channel"));
  137.     glist = g_list_append(NULL, list->selection->data);
  138.     gtk_list_remove_items(list, glist);
  139.  
  140.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_NONE);
  141. }
  142.  
  143. /* signal: join button pressed */
  144. static void sig_join(GtkWidget *widget, GtkList *list)
  145. {
  146.     SERVER_REC *server;
  147.     GtkEntry *entry;
  148.     char *data;
  149.  
  150.     g_return_if_fail(list != NULL);
  151.  
  152.     entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  153.     data = gtk_entry_get_text(entry);
  154.     if (*data == '\0') return;
  155.  
  156.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_NONE);
  157.  
  158.     server = cserver;
  159.     cserver = gtk_object_get_data(GTK_OBJECT(list), "server");
  160.     irccmd_join(data);
  161.     cserver = server;
  162. }
  163.  
  164. /* signal: list selection changed */
  165. static void sig_changed(GtkList *list)
  166. {
  167.     GtkEntry *entry;
  168.     char *data;
  169.  
  170.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_NONE);
  171.  
  172.     entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  173.  
  174.     if (list->selection != NULL)
  175.         data = gtk_object_get_data(GTK_OBJECT(list->selection->data), "channel");
  176.     else
  177.         data = "";
  178.     gtk_entry_set_text(entry, data);
  179. }
  180.  
  181. /* signal: entry activated */
  182. static void sig_activate(GtkWidget *widget, GtkList *list)
  183. {
  184.     GtkEntry *entry;
  185.     char *chan;
  186.  
  187.     switch ((int) gtk_object_get_data(GTK_OBJECT(list), "action"))
  188.     {
  189.         case ACTION_NONE:
  190.             sig_join(widget, list);
  191.             break;
  192.         case ACTION_EDIT:
  193.             {
  194.                 GtkWidget *old, *new;
  195.  
  196.                 old = list->selection->data;
  197.  
  198.                 entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  199.                 chan = gtk_entry_get_text(entry);
  200.  
  201.                 add_entry(list, chan);
  202.                 new = list->selection->data;
  203.  
  204.                 gtk_list_select_child(list, old);
  205.                 sig_delete_join(widget, list);
  206.                 gtk_list_select_child(list, new);
  207.             }
  208.             break;
  209.         case ACTION_ADD:
  210.             entry = gtk_object_get_data(GTK_OBJECT(list), "entry");
  211.             chan = gtk_entry_get_text(entry);
  212.  
  213.             add_entry(list, chan);
  214.             break;
  215.     }
  216.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_NONE);
  217. }
  218.  
  219. /* signal: cancel button pressed */
  220. static void sig_cancel(GtkWidget *window)
  221. {
  222.     GtkList *list;
  223.     GList *glist;
  224.  
  225.     for (glist = g_list_first(jointemp); glist != NULL; glist = glist->next)
  226.         g_free(glist->data);
  227.     g_list_free(jointemp); jointemp = NULL;
  228.  
  229.     list = gtk_object_get_data(GTK_OBJECT(window), "list");
  230.     for (glist = GTK_LIST(list)->children; glist != NULL; glist = glist->next)
  231.         g_free(gtk_object_get_data(GTK_OBJECT(glist->data), "channel"));
  232.  
  233.     gtk_widget_destroy(window);
  234.     joindlg = NULL;
  235. }
  236.  
  237. /* signal: ok button pressed */
  238. static void sig_save(GtkWidget *window)
  239. {
  240.     GList *tmp;
  241.  
  242.     for (tmp = g_list_first(joinlist); tmp != NULL; tmp = tmp->next)
  243.         g_free(tmp->data);
  244.     g_list_free(joinlist);
  245.  
  246.     joinlist = jointemp;
  247.     jointemp = NULL;
  248.  
  249.     gui_write_config();
  250.  
  251.     sig_cancel(window);
  252. }
  253.  
  254. /* signal: mouse button pressed */
  255. static void sig_mousedown(GtkList *list, GdkEventButton *event)
  256. {
  257.     if (event->button == 1)
  258.     {
  259.         if (!doubleclick)
  260.             doubleclick = 1;
  261.         else
  262.         {
  263.             doubleclick = 0;
  264.             sig_join(GTK_WIDGET(list), list);
  265.         }
  266.     }
  267. }
  268.  
  269. /* signal: mouse button released */
  270. static void sig_mouseup(GtkList *list, GdkEventButton *event)
  271. {
  272.     if (event->button == 1)
  273.     {
  274.         doubleclick = 0;
  275.     }
  276. }
  277.  
  278. void gui_join_dialog(SERVER_REC *server)
  279. {
  280.     GtkWidget *window;
  281.     GtkWidget *hbox;
  282.     GtkWidget *scrollbox;
  283.     GtkWidget *list;
  284.     GtkWidget *button;
  285.     GtkWidget *entry;
  286.     GList *tmp;
  287.  
  288.     if (joindlg != NULL)
  289.     {
  290.         /* join window already created */
  291.         gdk_window_raise(joindlg->window);
  292.         return;
  293.     }
  294.     doubleclick = 0;
  295.  
  296.     list = gtk_list_new();
  297.  
  298.     joindlg = window = gtk_dialog_new();
  299.     gtk_signal_connect (GTK_OBJECT (window), "delete_event",
  300.                         GTK_SIGNAL_FUNC(sig_cancel), window);
  301.     gtk_widget_set_usize(window, 250, 300);
  302.     gtk_object_set_data(GTK_OBJECT (window), "list", list);
  303.  
  304.     hbox = gtk_hbox_new(FALSE, 0);
  305.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), hbox, FALSE, FALSE, 10);
  306.     gtk_widget_show(hbox);
  307.  
  308.     /* add/edit/delete/join buttons */
  309.     button = gtk_button_new_with_label(_("Add"));
  310.     gtk_signal_connect (GTK_OBJECT (button), "clicked",
  311.                         GTK_SIGNAL_FUNC(sig_add_join), list);
  312.     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 10);
  313.     gtk_widget_show(button);
  314.     button = gtk_button_new_with_label(_("Edit"));
  315.     gtk_signal_connect (GTK_OBJECT (button), "clicked",
  316.                         GTK_SIGNAL_FUNC(sig_edit_join), list);
  317.     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 10);
  318.     gtk_widget_show(button);
  319.     button = gtk_button_new_with_label(_("Delete"));
  320.     gtk_signal_connect (GTK_OBJECT (button), "clicked",
  321.                         GTK_SIGNAL_FUNC(sig_delete_join), list);
  322.     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 10);
  323.     gtk_widget_show(button);
  324.     button = gtk_button_new_with_label(_("Join"));
  325.     gtk_signal_connect (GTK_OBJECT (button), "clicked",
  326.                         GTK_SIGNAL_FUNC(sig_join), list);
  327.     gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 10);
  328.     gtk_widget_show(button);
  329.  
  330.     /* list box */
  331.     scrollbox = gtk_scrolled_window_new(NULL, NULL);
  332.     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbox),
  333.                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  334.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), scrollbox, TRUE, TRUE, 0);
  335.     gtk_widget_show(scrollbox);
  336.  
  337.     gtk_list_set_selection_mode (GTK_LIST(list), GTK_SELECTION_BROWSE);
  338.     gtk_signal_connect (GTK_OBJECT (list), "button_press_event",
  339.                         GTK_SIGNAL_FUNC(sig_mousedown), NULL);
  340.     gtk_signal_connect (GTK_OBJECT (list), "button_release_event",
  341.                         GTK_SIGNAL_FUNC(sig_mouseup), NULL);
  342.     gtk_signal_connect (GTK_OBJECT (list), "selection_changed",
  343.                         GTK_SIGNAL_FUNC(sig_changed), NULL);
  344.     gtk_container_add(GTK_CONTAINER(scrollbox), list);
  345.     gtk_widget_show(list);
  346.  
  347.     /* entry */
  348.     entry = gtk_entry_new();
  349.     gtk_signal_connect (GTK_OBJECT (entry), "activate",
  350.                         GTK_SIGNAL_FUNC(sig_activate), list);
  351.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), entry, FALSE, FALSE, 0);
  352.     gtk_widget_show(entry);
  353.  
  354.     /* ok / cancel */
  355.     button = gtk_button_new_with_label (_("OK"));
  356.     gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->action_area), button, TRUE, TRUE, 10);
  357.     gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
  358.                                GTK_SIGNAL_FUNC (sig_save), GTK_OBJECT(window));
  359.     gtk_widget_show (button);
  360.  
  361.     button = gtk_button_new_with_label (_("Cancel"));
  362.     gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->action_area), button, TRUE, TRUE, 10);
  363.     gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
  364.                                GTK_SIGNAL_FUNC (sig_cancel), GTK_OBJECT(window));
  365.     gtk_widget_show (button);
  366.  
  367.     gtk_object_set_data(GTK_OBJECT(list), "server", server);
  368.     gtk_object_set_data(GTK_OBJECT(list), "entry", entry);
  369.     gtk_object_set_data(GTK_OBJECT(list), "action", (gpointer) ACTION_NONE);
  370.  
  371.     gtk_widget_grab_focus(entry);
  372.  
  373.     for (tmp = g_list_first(joinlist); tmp != NULL; tmp = tmp->next)
  374.         add_entry(GTK_LIST(list), (char *) tmp->data);
  375.  
  376.     gtk_widget_show(window);
  377. }
  378.