plugins/debug-manager/signals.c

   1 /*
   2     signals.c
   3     Copyright (C) 2000  Kh. Naba Kumar Singh
   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 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27
  28 #include <gnome.h>
  29
  30 #include <libanjuta/resources.h>
  31
  32 #include "utilities.h"
  33 #include "signals.h"
  34
  35 static GtkWidget* create_signals_set_dialog (Signals *s);
  36
  37 static void
  38 signals_update_controls (Signals * ew)
  39 {
  40         gboolean R, Pr;
  41
  42         R = ianjuta_debugger_get_status (ew->debugger, NULL) == IANJUTA_DEBUGGER_OK;
  43         Pr = ianjuta_debugger_get_status (ew->debugger, NULL) == IANJUTA_DEBUGGER_PROGRAM_RUNNING;
  44         gtk_widget_set_sensitive (ew->widgets.menu_signal, Pr);
  45         gtk_widget_set_sensitive (ew->widgets.menu_modify, R);
  46         gtk_widget_set_sensitive (ew->widgets.menu_update, R);
  47 }
  48
  49 static void
  50 signals_update (const GList * lines, gpointer data)
  51 {
  52         Signals *sg;
  53         gint j, count;
  54         gchar *row[5], *str;
  55         gchar sig[32], stop[10], print[10], pass[10];
  56         GList *list, *node;
  57
  58         sg = (Signals *) data;
  59         signals_clear (sg);
  60         list = gdb_util_remove_blank_lines (lines);
  61         if (g_list_length (list) < 2)
  62         {
  63                 g_list_free (list);
  64                 return;
  65         }
  66         gtk_clist_freeze (GTK_CLIST(sg->widgets.clist));
  67         node = list->next;
  68         while (node)
  69         {
  70                 count =
  71                         sscanf ((char *) node->data, "%s %s %s %s", sig, stop, print, pass);
  72                 str = node->data;
  73                 node = g_list_next (node);
  74                 if (count != 4)
  75                         continue;
  76
  77                 /* Do not worry. This is used to avoid the last line */
  78                 if (node == NULL)
  79                         break;
  80                 row[0] = sig;
  81                 row[1] = stop;
  82                 row[2] = print;
  83                 row[3] = pass;
  84                 for (j = 0; j < 4; j++)
  85                 {
  86                         while (isspace (*str))
  87                                 str++;
  88                         while (!isspace (*str))
  89                                 str++;
  90                 }
  91                 while (isspace (*str))
  92                         str++;
  93                 row[4] = str;
  94                 gtk_clist_append (GTK_CLIST (sg->widgets.clist), row);
  95         }
  96         g_list_free (list);
  97         gtk_clist_thaw (GTK_CLIST(sg->widgets.clist));
  98 }
  99
 100 static void
 101 on_signals_clist_select_row (GtkCList *clist, gint row,
 102                                                          gint column, GdkEvent *event, gpointer user_data)
 103 {
 104     Signals *s = (Signals*)user_data;
 105     s->idx = row;
 106 }
 107
 108 static gint
 109 on_signals_delete_event(GtkWidget* w, GdkEvent *event, gpointer data)
 110 {
 111         Signals* cr = (Signals*) data;
 112         signals_hide (cr);
 113         return TRUE;
 114 }
 115
 116 static gboolean
 117 on_signals_key_press_event(GtkWidget *widget, GdkEventKey *event,
 118                                                    gpointer data)
 119 {
 120         if (event->keyval == GDK_Escape)
 121         {
 122                 Signals* cr = (Signals*) data;
 123                 signals_hide(cr);
 124                 return TRUE;
 125         }
 126         return FALSE;
 127 }
 128
 129 static void
 130 on_signals_modify_activate (GtkMenuItem *menuitem, gpointer user_data)
 131 {
 132         GtkWidget* dialog;
 133     Signals *s = (Signals*)user_data;
 134
 135         dialog = create_signals_set_dialog (s);
 136         if (dialog)
 137                 gtk_widget_show (dialog);
 138 }
 139
 140 static void
 141 on_signals_send_activate (GtkMenuItem *menuitem, gpointer user_data)
 142 {
 143         #if 0
 144         gchar* sig;
 145     Signals *s = (Signals*)user_data;
 146
 147         if (debugger_program_is_running (s->debugger) == FALSE) return;
 148
 149         signals_show (s);
 150         gtk_clist_get_text(GTK_CLIST (s->widgets.clist), s->idx, 0, &sig);
 151         debugger_signal(sig, TRUE);
 152         #endif
 153 }
 154
 155 static void
 156 on_signals_update_activate (GtkMenuItem *menuitem, gpointer user_data)
 157 {
 158     Signals *s = (Signals*)user_data;
 159         ianjuta_debugger_info_signal (
 160                         s->debugger,
 161                         (IAnjutaDebuggerCallback)signals_update,
 162                         s,
 163                         NULL);
 164 }
 165
 166 static gboolean
 167 on_signals_event (GtkWidget *widget, GdkEvent  *event, gpointer user_data)
 168 {
 169         GdkEventButton *bevent;
 170     Signals *ew = (Signals*)user_data;
 171
 172         if (event->type != GDK_BUTTON_PRESS) return FALSE;
 173         if (((GdkEventButton *)event)->button != 3) return FALSE;
 174
 175         bevent =  (GdkEventButton *)event;
 176         bevent->button = 1;
 177         signals_update_controls(ew);
 178         gtk_menu_popup (GTK_MENU(ew->widgets.menu), NULL,
 179                                         NULL, NULL, NULL,
 180                                         bevent->button, bevent->time);
 181         return TRUE;
 182 }
 183
 184 static void
 185 on_signals_togglebutton1_toggled (GtkToggleButton *togglebutton,
 186                                                                   gpointer user_data)
 187 {
 188         Signals *sig = (Signals*) user_data;
 189
 190         sig->stop = gtk_toggle_button_get_active (togglebutton);
 191         if (sig->stop)
 192                 gtk_label_set_text (GTK_LABEL(GTK_BIN (togglebutton)->child), _("Yes"));
 193     else
 194                 gtk_label_set_text (GTK_LABEL(GTK_BIN (togglebutton)->child), _("No"));
 195 }
 196
 197 static void
 198 on_signals_togglebutton2_toggled (GtkToggleButton *togglebutton,
 199                                                                   gpointer user_data)
 200 {
 201         Signals *sig = (Signals*) user_data;
 202
 203         sig->print = gtk_toggle_button_get_active(togglebutton);
 204         if (sig->print)
 205                 gtk_label_set_text (GTK_LABEL(GTK_BIN(togglebutton)->child), _("Yes"));
 206     else
 207                 gtk_label_set_text (GTK_LABEL(GTK_BIN(togglebutton)->child), _("No"));
 208 }
 209
 210 static void
 211 on_signals_togglebutton3_toggled (GtkToggleButton *togglebutton,
 212                                                                   gpointer user_data)
 213 {
 214         Signals *sig = (Signals*) user_data;
 215
 216         sig->pass = gtk_toggle_button_get_active (togglebutton);
 217         if (sig->pass)
 218                 gtk_label_set_text (GTK_LABEL(GTK_BIN(togglebutton)->child), _("Yes"));
 219     else
 220                 gtk_label_set_text (GTK_LABEL(GTK_BIN(togglebutton)->child), _("No"));
 221 }
 222
 223 static void
 224 on_signals_set_ok_clicked              (GtkButton       *button,
 225                                         gpointer         user_data)
 226 {
 227         Signals *s = (Signals*) user_data;
 228
 229         if(s->stop)
 230         {
 231                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 1, "Yes");
 232         }
 233         else
 234         {
 235                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 1, "No");
 236         }
 237         if(s->print)
 238         {
 239                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 2, "Yes");
 240         }
 241         else
 242         {
 243                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 2, "No");
 244         }
 245         if(s->pass)
 246         {
 247                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 3, "Yes");
 248         }
 249         else
 250         {
 251                 gtk_clist_set_text(GTK_CLIST(s->widgets.clist), s->idx, 3, "No");
 252         }
 253         ianjuta_debugger_handle_signal (s->debugger, s->signal, s->stop, s->print, s->pass, NULL);
 254 }
 255
 256 static GnomeUIInfo signals_menu_uiinfo[] =
 257 {
 258         {
 259                 GNOME_APP_UI_ITEM, N_("Modify Signal"),
 260                 NULL,
 261                 on_signals_modify_activate, NULL, NULL,
 262                 GNOME_APP_PIXMAP_NONE, NULL,
 263                 0, 0, NULL
 264         },
 265         {
 266                 GNOME_APP_UI_ITEM, N_("Send to process"),
 267                 NULL,
 268                 on_signals_send_activate, NULL, NULL,
 269                 GNOME_APP_PIXMAP_NONE, NULL,
 270                 0, 0, NULL
 271         },
 272         {
 273                 GNOME_APP_UI_ITEM, N_("Update"),
 274                 NULL,
 275                 on_signals_update_activate, NULL, NULL,
 276                 GNOME_APP_PIXMAP_NONE, NULL,
 277                 0, 0, NULL
 278         },
 279         GNOMEUIINFO_END
 280 };
 281
 282 static GtkWidget*
 283 create_signals_menu (Signals *s)
 284 {
 285         GtkWidget *signals_menu;
 286
 287         signals_menu = gtk_menu_new ();
 288
 289         signals_menu_uiinfo[0].user_data = s;
 290         signals_menu_uiinfo[1].user_data = s;
 291         signals_menu_uiinfo[2].user_data = s;
 292
 293         gnome_app_fill_menu (GTK_MENU_SHELL (signals_menu), signals_menu_uiinfo,
 294                                                  NULL, FALSE, 0);
 295         return signals_menu;
 296 }
 297
 298 static void
 299 create_signals_gui (Signals *cr)
 300 {
 301         GtkWidget *window3;
 302         GtkWidget *scrolledwindow4;
 303         GtkWidget *clist4;
 304         GtkWidget *label6, *label7, *label8, *label9, *label10;
 305
 306         window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 307         gtk_widget_set_usize (window3, 170, -2);
 308         gtk_window_set_title (GTK_WINDOW (window3), _("Kernel signals"));
 309         gtk_window_set_wmclass (GTK_WINDOW (window3), "signals", "Anjuta");
 310         gtk_window_set_default_size (GTK_WINDOW (window3), 240, 230);
 311         gnome_window_icon_set_from_default(GTK_WINDOW(window3));
 312
 313         scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
 314         gtk_widget_show (scrolledwindow4);
 315         gtk_container_add (GTK_CONTAINER (window3), scrolledwindow4);
 316         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4),
 317                                                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 318
 319         clist4 = gtk_clist_new (5);
 320         gtk_widget_show (clist4);
 321         gtk_container_add (GTK_CONTAINER (scrolledwindow4), clist4);
 322         gtk_clist_set_column_width (GTK_CLIST (clist4), 0, 100);
 323         gtk_clist_set_column_width (GTK_CLIST (clist4), 1, 50);
 324         gtk_clist_set_column_width (GTK_CLIST (clist4), 2, 50);
 325         gtk_clist_set_column_width (GTK_CLIST (clist4), 3, 50);
 326         gtk_clist_set_column_width (GTK_CLIST (clist4), 4, 80);
 327         gtk_clist_set_selection_mode (GTK_CLIST (clist4), GTK_SELECTION_BROWSE);
 328         gtk_clist_column_titles_show (GTK_CLIST (clist4));
 329         gtk_clist_set_column_auto_resize (GTK_CLIST(clist4), 4, TRUE);
 330
 331         label6 = gtk_label_new (_("Signal"));
 332         gtk_widget_show (label6);
 333         gtk_clist_set_column_widget (GTK_CLIST (clist4), 0, label6);
 334
 335         label7 = gtk_label_new (_("Stop"));
 336         gtk_widget_show (label7);
 337         gtk_clist_set_column_widget (GTK_CLIST (clist4), 1, label7);
 338
 339         label8 = gtk_label_new (_("Print"));
 340         gtk_widget_show (label8);
 341         gtk_clist_set_column_widget (GTK_CLIST (clist4), 2, label8);
 342
 343         label9 = gtk_label_new (_("Pass"));
 344         gtk_widget_show (label9);
 345         gtk_clist_set_column_widget (GTK_CLIST (clist4), 3, label9);
 346
 347         label10 = gtk_label_new (_("Description"));
 348         gtk_widget_show (label10);
 349         gtk_clist_set_column_widget (GTK_CLIST (clist4), 4, label10);
 350
 351         gtk_signal_connect (GTK_OBJECT (window3), "delete_event",
 352                                                 GTK_SIGNAL_FUNC (on_signals_delete_event), cr);
 353         gtk_signal_connect (GTK_OBJECT (window3), "key-press-event",
 354                                                 GTK_SIGNAL_FUNC (on_signals_key_press_event), cr);
 355
 356         gtk_signal_connect (GTK_OBJECT (clist4), "event",
 357                                                 GTK_SIGNAL_FUNC (on_signals_event),
 358                                                 cr);
 359         gtk_signal_connect (GTK_OBJECT (clist4), "select_row",
 360                                                 GTK_SIGNAL_FUNC (on_signals_clist_select_row),
 361                                                 cr);
 362
 363         cr->widgets.window = window3;
 364         cr->widgets.clist = clist4;
 365         cr->widgets.menu = create_signals_menu (cr);
 366         cr->widgets.menu_modify = signals_menu_uiinfo[0].widget;
 367         cr->widgets.menu_signal = signals_menu_uiinfo[1].widget;
 368         cr->widgets.menu_update = signals_menu_uiinfo[2].widget;
 369 }
 370
 371 static GtkWidget*
 372 create_signals_set_dialog (Signals *s)
 373 {
 374         GtkWidget *dialog1;
 375         GtkWidget *dialog_vbox1;
 376         GtkWidget *hbox1;
 377         GtkWidget *label1;
 378         GtkWidget *label2;
 379         GtkWidget *hbox2;
 380         GtkWidget *label3;
 381         GtkWidget *label4;
 382         GtkWidget *hseparator1;
 383         GtkWidget *hbox4;
 384         GtkWidget *label5;
 385         GtkWidget *label6;
 386         GtkWidget *label7;
 387         GtkWidget *hbox3;
 388         GtkWidget *togglebutton1;
 389         GtkWidget *togglebutton2;
 390         GtkWidget *togglebutton3;
 391         GtkWidget *dialog_action_area1;
 392         GtkWidget *button1;
 393         GtkWidget *button2;
 394         GtkWidget *button3;
 395         gchar *row[5];
 396
 397         if(s->idx < 0)
 398                 return NULL;
 399
 400         gtk_clist_get_text(GTK_CLIST(s->widgets.clist), s->idx,0, &row[0]);
 401         gtk_clist_get_text(GTK_CLIST(s->widgets.clist), s->idx,1, &row[1]);
 402         gtk_clist_get_text(GTK_CLIST(s->widgets.clist), s->idx,2, &row[2]);
 403         gtk_clist_get_text(GTK_CLIST(s->widgets.clist), s->idx,3, &row[3]);
 404         gtk_clist_get_text(GTK_CLIST(s->widgets.clist), s->idx,4, &row[4]);
 405         s->signal = row[0];
 406
 407         if(strcasecmp(row[1], "Yes")==0)
 408                 s->stop = TRUE;
 409         else
 410                 s->stop = FALSE;
 411
 412         if(strcasecmp(row[2], "Yes")==0)
 413                 s->print = TRUE;
 414         else
 415                 s->print = FALSE;
 416
 417         if(strcasecmp(row[3], "Yes")==0)
 418                 s->pass = TRUE;
 419         else
 420                 s->pass = FALSE;
 421
 422         dialog1 = gnome_dialog_new (_("Set Signal Property"), NULL);
 423         gtk_window_set_transient_for (GTK_WINDOW(dialog1),
 424                                                                   GTK_WINDOW(s->widgets.window));
 425         GTK_WINDOW (dialog1)->type = GTK_WINDOW_TOPLEVEL;
 426         gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_MOUSE);
 427         gtk_window_set_policy (GTK_WINDOW (dialog1), FALSE, FALSE, FALSE);
 428         gtk_window_set_wmclass (GTK_WINDOW (dialog1), "set_signal", "Anjuta");
 429         gnome_dialog_set_close (GNOME_DIALOG (dialog1), TRUE);
 430
 431         dialog_vbox1 = GNOME_DIALOG (dialog1)->vbox;
 432         gtk_widget_show (dialog_vbox1);
 433
 434         hbox1 = gtk_hbox_new (FALSE, 0);
 435         gtk_widget_show (hbox1);
 436         gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
 437
 438         label1 = gtk_label_new ("Signal: ");
 439         gtk_widget_show (label1);
 440         gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
 441
 442         label2 = gtk_label_new (row[0]);
 443         gtk_widget_show (label2);
 444         gtk_box_pack_start (GTK_BOX (hbox1), label2, FALSE, FALSE, 0);
 445
 446         hbox2 = gtk_hbox_new (FALSE, 0);
 447         gtk_widget_show (hbox2);
 448         gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox2, TRUE, TRUE, 0);
 449
 450         label3 = gtk_label_new ("Description: ");
 451         gtk_widget_show (label3);
 452         gtk_box_pack_start (GTK_BOX (hbox2), label3, FALSE, FALSE, 0);
 453
 454         label4 = gtk_label_new (row[4]);
 455         gtk_widget_show (label4);
 456         gtk_box_pack_start (GTK_BOX (hbox2), label4, FALSE, FALSE, 0);
 457
 458         hseparator1 = gtk_hseparator_new ();
 459         gtk_widget_show (hseparator1);
 460         gtk_box_pack_start (GTK_BOX (dialog_vbox1), hseparator1, TRUE, TRUE, 0);
 461
 462         hbox4 = gtk_hbox_new (FALSE, 0);
 463         gtk_widget_show (hbox4);
 464         gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox4, TRUE, TRUE, 0);
 465
 466         label5 = gtk_label_new (_(" Stop: "));
 467         gtk_widget_show (label5);
 468         gtk_box_pack_start (GTK_BOX (hbox4), label5, TRUE, TRUE, 0);
 469
 470         label6 = gtk_label_new (_(" Print: "));
 471         gtk_widget_show (label6);
 472         gtk_box_pack_start (GTK_BOX (hbox4), label6, TRUE, TRUE, 0);
 473
 474         label7 = gtk_label_new (_("Pass:"));
 475         gtk_widget_show (label7);
 476         gtk_box_pack_start (GTK_BOX (hbox4), label7, TRUE, TRUE, 0);
 477
 478         hbox3 = gtk_hbox_new (FALSE, 0);
 479         gtk_widget_show (hbox3);
 480         gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox3, TRUE, TRUE, 0);
 481
 482         togglebutton1 = gtk_toggle_button_new_with_label (row[1]);
 483         gtk_widget_show (togglebutton1);
 484         gtk_box_pack_start (GTK_BOX (hbox3), togglebutton1, TRUE, TRUE, 0);
 485         gtk_container_set_border_width (GTK_CONTAINER (togglebutton1), 3);
 486         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton1), s->stop);
 487
 488         togglebutton2 = gtk_toggle_button_new_with_label (row[2]);
 489         gtk_widget_show (togglebutton2);
 490         gtk_box_pack_start (GTK_BOX (hbox3), togglebutton2, TRUE, TRUE, 0);
 491         gtk_container_set_border_width (GTK_CONTAINER (togglebutton2), 3);
 492         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton2), s->print);
 493
 494         togglebutton3 = gtk_toggle_button_new_with_label (row[3]);
 495         gtk_widget_show (togglebutton3);
 496         gtk_box_pack_start (GTK_BOX (hbox3), togglebutton3, TRUE, TRUE, 0);
 497         gtk_container_set_border_width (GTK_CONTAINER (togglebutton3), 3);
 498         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(togglebutton3), s->pass);
 499
 500         dialog_action_area1 = GNOME_DIALOG (dialog1)->action_area;
 501         gtk_widget_show (dialog_action_area1);
 502         gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),
 503                                                            GTK_BUTTONBOX_SPREAD);
 504         gtk_button_box_set_spacing (GTK_BUTTON_BOX (dialog_action_area1), 8);
 505
 506         gnome_dialog_append_button (GNOME_DIALOG (dialog1),
 507                                                                 GNOME_STOCK_BUTTON_HELP);
 508         button1 = g_list_last (GNOME_DIALOG (dialog1)->buttons)->data;
 509         gtk_widget_show (button1);
 510         GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
 511
 512         gnome_dialog_append_button (GNOME_DIALOG (dialog1), GNOME_STOCK_BUTTON_OK);
 513         button2 = g_list_last (GNOME_DIALOG (dialog1)->buttons)->data;
 514         gtk_widget_show (button2);
 515         GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
 516
 517         gnome_dialog_append_button (GNOME_DIALOG (dialog1),
 518                                                                 GNOME_STOCK_BUTTON_CANCEL);
 519         button3 = g_list_last (GNOME_DIALOG (dialog1)->buttons)->data;
 520         gtk_widget_show (button3);
 521         GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT);
 522
 523         gtk_signal_connect (GTK_OBJECT (togglebutton1), "toggled",
 524                                                 GTK_SIGNAL_FUNC (on_signals_togglebutton1_toggled),
 525                                                 s);
 526         gtk_signal_connect (GTK_OBJECT (togglebutton2), "toggled",
 527                                                 GTK_SIGNAL_FUNC (on_signals_togglebutton2_toggled),
 528                                                 s);
 529         gtk_signal_connect (GTK_OBJECT (togglebutton3), "toggled",
 530                                                 GTK_SIGNAL_FUNC (on_signals_togglebutton3_toggled),
 531                                                 s);
 532         gtk_signal_connect (GTK_OBJECT (button2), "clicked",
 533                                                 GTK_SIGNAL_FUNC (on_signals_set_ok_clicked),
 534                                                 s);
 535         return dialog1;
 536 }
 537
 538 Signals *
 539 signals_new (IAnjutaDebugger *debugger)
 540 {
 541         Signals *ew;
 542         ew = g_malloc (sizeof (Signals));
 543         if (ew)
 544         {
 545                 ew->debugger = debugger;
 546                 g_object_ref (debugger);
 547                 ew->is_showing = FALSE;
 548                 ew->win_width = 460;
 549                 ew->win_height = 320;
 550                 ew->win_pos_x = 150;
 551                 ew->win_pos_y = 130;
 552                 ew->idx = -1;
 553                 create_signals_gui (ew);
 554         }
 555         return ew;
 556 }
 557
 558 void
 559 signals_clear (Signals * sg)
 560 {
 561         if (GTK_IS_CLIST (sg->widgets.clist))
 562                 gtk_clist_clear (GTK_CLIST (sg->widgets.clist));
 563         sg->idx = -1;
 564 }
 565
 566 void
 567 signals_show (Signals * ew)
 568 {
 569         if (ew)
 570         {
 571                 if (ew->is_showing)
 572                 {
 573                         gdk_window_raise (ew->widgets.window->window);
 574                 }
 575                 else
 576                 {
 577                         gtk_widget_set_uposition (ew->widgets.window, ew->win_pos_x,
 578                                                                           ew->win_pos_y);
 579                         gtk_window_set_default_size (GTK_WINDOW (ew->widgets.window),
 580                                                                                  ew->win_width, ew->win_height);
 581                         gtk_widget_show (ew->widgets.window);
 582                         ew->is_showing = TRUE;
 583                         ianjuta_debugger_info_signal (
 584                                         ew->debugger,
 585                                         (IAnjutaDebuggerCallback)signals_update,
 586                                         ew,
 587                                         NULL);
 588                 }
 589         }
 590 }
 591
 592 void
 593 signals_hide (Signals * ew)
 594 {
 595         if (ew)
 596         {
 597                 if (ew->is_showing == FALSE)
 598                         return;
 599                 gdk_window_get_root_origin (ew->widgets.window->window, &ew->win_pos_x,
 600                                                                         &ew->win_pos_y);
 601                 gdk_window_get_size (ew->widgets.window->window, &ew->win_width,
 602                                                          &ew->win_height);
 603                 gtk_widget_hide (ew->widgets.window);
 604                 ew->is_showing = FALSE;
 605         }
 606 }
 607
 608 void
 609 signals_free (Signals * sg)
 610 {
 611         if (sg)
 612         {
 613                 signals_clear (sg);
 614                 g_object_unref (sg->debugger);
 615                 gtk_widget_destroy (sg->widgets.window);
 616                 gtk_widget_destroy (sg->widgets.menu);
 617                 g_free (sg);
 618         }
 619 }