/[xlog]/xlog/src/callbacks_otherdialogs.c
ViewVC logotype

Diff of /xlog/src/callbacks_otherdialogs.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.22 by pa4tu, Wed Aug 27 10:36:19 2003 UTC revision 1.23 by pa4tu, Wed Oct 1 22:35:56 2003 UTC
# Line 53  extern statetype state; Line 53  extern statetype state;
53  extern GtkWidget *b4dialog;  extern GtkWidget *b4dialog;
54  extern GList *searchhistory;  extern GList *searchhistory;
55  extern GList *logwindowlist;  extern GList *logwindowlist;
56  gchar *globtemp;  
57  gint globtype = 1;  /* globals for save as dialog */
58    gchar *logfile;
59    gint type = 1;
60    gint highqso, lowqso;
61    
62  #if WANT_HAMLIB  #if WANT_HAMLIB
63    extern gint saved_fd;  extern gint saved_fd;
64    extern gint tracetimer;  extern gint tracetimer;
65    extern fileinfo finfo;  extern fileinfo finfo;
66  #endif  #endif
67    
68  /* qsort/bsearch callback functions */  /* qsort/bsearch callback functions */
# Line 69  typedef int (*compar_callback_fn) (const Line 72  typedef int (*compar_callback_fn) (const
72  void  void
73  on_setupbutton_clicked (GtkButton * button, gpointer user_data)  on_setupbutton_clicked (GtkButton * button, gpointer user_data)
74  {  {
75    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
76    gtk_widget_show (mainwindow);          gtk_widget_show (mainwindow);
77    gdk_window_move_resize (mainwindow->window, preferences.x, preferences.y,          gdk_window_move_resize (mainwindow->window, preferences.x,
78                            preferences.width, preferences.height);                                  preferences.y, preferences.width,
79                                    preferences.height);
80  }  }
81    
82  /* setup dialog is deleted */  /* setup dialog is deleted */
# Line 80  gboolean Line 84  gboolean
84  on_setupdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_setupdialog_delete_event (GtkWidget * widget, GdkEvent * event,
85                               gpointer user_data)                               gpointer user_data)
86  {  {
87    gtk_widget_show (mainwindow);          gtk_widget_show (mainwindow);
88    gdk_window_move_resize (mainwindow->window, preferences.x, preferences.y,          gdk_window_move_resize (mainwindow->window, preferences.x,
89                            preferences.width, preferences.height);                                  preferences.y, preferences.width,
90    return FALSE;                                  preferences.height);
91            return FALSE;
92  }  }
93    
94    
# Line 91  on_setupdialog_delete_event (GtkWidget * Line 96  on_setupdialog_delete_event (GtkWidget *
96  void  void
97  on_saveokbutton_clicked (GtkButton * button, gpointer user_data)  on_saveokbutton_clicked (GtkButton * button, gpointer user_data)
98  {  {
99    save_windowsize_and_cleanup ();          save_windowsize_and_cleanup ();
100    gtk_main_quit ();          gtk_main_quit ();
101  }  }
102    
103  /* cancel clicked, nothing saved */  /* cancel clicked, nothing saved */
104  void  void
105  on_savecancelbutton_clicked (GtkButton * button, gpointer user_data)  on_savecancelbutton_clicked (GtkButton * button, gpointer user_data)
106  {  {
107    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
108    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
109  }  }
110    
111  /* save dialog is deleted */  /* save dialog is deleted */
# Line 108  gboolean Line 113  gboolean
113  on_savedialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_savedialog_delete_event (GtkWidget * widget, GdkEvent * event,
114                              gpointer user_data)                              gpointer user_data)
115  {  {
116    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
117    return FALSE;          return FALSE;
118  }  }
119    
120    
121  /* SEARCH DIALOG */  /* SEARCH DIALOG */
122    
123  gboolean  gboolean
124  comparecalls (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,  comparecalls (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter,
125    gchar *str)                gchar * str)
126  {  {
127          gchar *callsign;          gchar *callsign;
128    
129          gtk_tree_model_get (model, iter, CALL, &callsign, -1);          gtk_tree_model_get (model, iter, CALL, &callsign, -1);
130            if (g_strrstr (str, callsign))          if (g_strrstr (str, callsign))
131                    return TRUE;                  return TRUE;
132            else          else
133                    return FALSE;                  return FALSE;
134  }  }
135    
136  void  void
137  on_searchokbutton_clicked (GtkButton * button, gpointer user_data)  on_searchokbutton_clicked (GtkButton * button, gpointer user_data)
138  {  {
139    gchar *searchstr, *upsearchstr, *callsign, *labeltext, *current, *nr;          gchar *searchstr, *upsearchstr, *callsign, *labeltext, *current, *nr;
140    GtkWidget *searchdialog, *searchresultdialog, *searchcomboentry,          GtkWidget *searchdialog, *searchresultdialog, *searchcomboentry,
141      *resultlabel, *searchcheckbutton, *searchcombo;                  *resultlabel, *searchcheckbutton, *searchcombo;
142    gint i;          gint i;
143    gboolean result = FALSE, searchopen;          gboolean result = FALSE, searchopen;
144    GList *node;          GList *node;
145    logtype *logwindow;          logtype *logwindow;
146    GtkTreeModel *model;          GtkTreeModel *model;
147    GtkTreeIter iter;          GtkTreeIter iter;
148    GtkTreeSelection *selection;          GtkTreeSelection *selection;
149    GtkTreePath *path;          GtkTreePath *path;
150    gboolean valid;          gboolean valid;
151      
152    searchdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));          searchdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
153    searchcombo = lookup_widget (searchdialog, "searchcombo");          searchcombo = lookup_widget (searchdialog, "searchcombo");
154    searchcomboentry = lookup_widget (searchdialog, "searchcomboentry");          searchcomboentry = lookup_widget (searchdialog, "searchcomboentry");
155    searchcheckbutton = lookup_widget (searchdialog, "searchcheckbutton");          searchcheckbutton = lookup_widget (searchdialog, "searchcheckbutton");
156    
157    searchopen = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON          searchopen = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
158                                               (searchcheckbutton));                                                     (searchcheckbutton));
159    
160    searchstr = gtk_editable_get_chars (GTK_EDITABLE (searchcomboentry), 0, -1);          searchstr =
161                    gtk_editable_get_chars (GTK_EDITABLE (searchcomboentry), 0,
162    node = g_list_find_custom (searchhistory, g_strdup (searchstr),                                          -1);
163                               (GCompareFunc) strncmp);  
164    if (!node)          node = g_list_find_custom (searchhistory, g_strdup (searchstr),
165      searchhistory = g_list_prepend (searchhistory, g_strdup (searchstr));                                     (GCompareFunc) strncmp);
166    if (g_list_length (searchhistory) > SEARCHHISTORY)          if (!node)
167      searchhistory = g_list_remove (searchhistory,                  searchhistory =
168                                     g_list_last (searchhistory)->data);                          g_list_prepend (searchhistory, g_strdup (searchstr));
169            if (g_list_length (searchhistory) > SEARCHHISTORY)
170                    searchhistory = g_list_remove (searchhistory,
171                                                   g_list_last (searchhistory)->
172                                                   data);
173    
174    upsearchstr = g_ascii_strup (searchstr, -1);          upsearchstr = g_ascii_strup (searchstr, -1);
175    
176    for (i = 0; i < g_list_length (logwindowlist); i++)          for (i = 0; i < g_list_length (logwindowlist); i++)
177      {          {
178        logwindow = g_list_nth_data (logwindowlist, i);                  logwindow = g_list_nth_data (logwindowlist, i);
179            model = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                  model = gtk_tree_view_get_model (GTK_TREE_VIEW
180            valid = gtk_tree_model_get_iter_first (model, &iter);                                                   (logwindow->treeview));
181            while (valid)                  valid = gtk_tree_model_get_iter_first (model, &iter);
182            {                  while (valid)
183                  gtk_tree_model_get (model, &iter, CALL, &callsign, -1);                  {
184                    if (g_strrstr (callsign, upsearchstr))                          gtk_tree_model_get (model, &iter, CALL, &callsign,
185                    {                                              -1);
186                          /* construct an id for this search */                          if (g_strrstr (callsign, upsearchstr))
                         current = g_strdup_printf("%d", i);  
                         gtk_tree_model_get (model, &iter, NR, &nr, -1);  
                         current = g_strconcat(current, "/", nr, NULL);  
                         if (!g_strrstr (state.searchstr, current))  
187                          {                          {
188                    gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook), i);                                  /* construct an id for this search */
189                            selection = gtk_tree_view_get_selection                                  current = g_strdup_printf ("%d", i);
190                                  (GTK_TREE_VIEW(logwindow->treeview));                                  gtk_tree_model_get (model, &iter, NR, &nr,
191                            gtk_tree_selection_select_iter (selection, &iter);                                                      -1);
192                path = gtk_tree_model_get_path (model, &iter);                                  current =
193                            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(logwindow->treeview),                                          g_strconcat (current, "/", nr, NULL);
194                          path, NULL, TRUE, 0.5, 0.0);                                  if (!g_strrstr (state.searchstr, current))
195                    gtk_tree_path_free (path);                                  {
196                            /* add id to the array */                                          gtk_notebook_set_current_page
197                            state.searchstr = g_strconcat(state.searchstr, current, ",", NULL);                                                  (GTK_NOTEBOOK (mainnotebook),
198                result = TRUE;                                                   i);
199                            break;                                          selection =
200                                                    gtk_tree_view_get_selection
201                                                    (GTK_TREE_VIEW
202                                                     (logwindow->treeview));
203                                            gtk_tree_selection_select_iter
204                                                    (selection, &iter);
205                                            path = gtk_tree_model_get_path (model,
206                                                                            &iter);
207                                            gtk_tree_view_scroll_to_cell
208                                                    (GTK_TREE_VIEW
209                                                     (logwindow->treeview), path,
210                                                     NULL, TRUE, 0.5, 0.0);
211                                            gtk_tree_path_free (path);
212                                            /* add id to the array */
213                                            state.searchstr =
214                                                    g_strconcat (state.searchstr,
215                                                                 current, ",",
216                                                                 NULL);
217                                            result = TRUE;
218                                            break;
219                                    }
220                          }                          }
221                    }                          valid = gtk_tree_model_iter_next (model, &iter);
222              valid = gtk_tree_model_iter_next (model, &iter);                  }
223            }                  if (result)
224            if (result) break;                          break;
225      }          }
226    
227    if (!result)          if (!result)
228      {          {
229            state.searchstr = g_strdup("");                  state.searchstr = g_strdup ("");
230        searchresultdialog = create_searchresultdialog ();                  searchresultdialog = create_searchresultdialog ();
231        resultlabel = lookup_widget (searchresultdialog, "resultlabel");                  resultlabel =
232        labeltext = g_strdup_printf (_("\'%s\' was not found"), searchstr);                          lookup_widget (searchresultdialog, "resultlabel");
233        gtk_label_set_text (GTK_LABEL (resultlabel), labeltext);                  labeltext =
234        g_free (labeltext);                          g_strdup_printf (_("\'%s\' was not found"),
235        gtk_widget_show (searchresultdialog);                                           searchstr);
236      }                  gtk_label_set_text (GTK_LABEL (resultlabel), labeltext);
237                    g_free (labeltext);
238                    gtk_widget_show (searchresultdialog);
239            }
240    
241    g_free (searchstr);          g_free (searchstr);
242    g_free (upsearchstr);          g_free (upsearchstr);
243    
244    
245    if (!searchopen)          if (!searchopen)
246      {            {
247        state.searchstr = g_strdup("");                  state.searchstr = g_strdup ("");
248            gtk_widget_set_sensitive (mainwindow, 1);                  gtk_widget_set_sensitive (mainwindow, 1);
249        gtk_widget_destroy (searchdialog);                  gtk_widget_destroy (searchdialog);
250      }          }
251    else          else
252    {          {
253      if (searchhistory)                  if (searchhistory)
254        gtk_combo_set_popdown_strings (GTK_COMBO (searchcombo), searchhistory);                          gtk_combo_set_popdown_strings (GTK_COMBO
255    }                                                         (searchcombo),
256                                                           searchhistory);
257            }
258  }  }
259    
260    
# Line 232  on_searchokbutton_clicked (GtkButton * b Line 262  on_searchokbutton_clicked (GtkButton * b
262  void  void
263  on_searchcancelbutton_clicked (GtkButton * button, gpointer user_data)  on_searchcancelbutton_clicked (GtkButton * button, gpointer user_data)
264  {  {
265    state.searchstr = g_strdup("");          state.searchstr = g_strdup ("");
266    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
267    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
268  }  }
269    
270  /* search changed, reset saved state */  /* search changed, reset saved state */
271  void  void
272  on_searchcomboentry_changed (GtkEditable * editable, gpointer user_data)  on_searchcomboentry_changed (GtkEditable * editable, gpointer user_data)
273  {  {
274    state.searchstr = g_strdup("");          state.searchstr = g_strdup ("");
275  }  }
276    
277  /* toggle 'keep this dialog open' */  /* toggle 'keep this dialog open' */
# Line 249  void Line 279  void
279  on_searchcheckbutton_toggled (GtkToggleButton * togglebutton,  on_searchcheckbutton_toggled (GtkToggleButton * togglebutton,
280                                gpointer user_data)                                gpointer user_data)
281  {  {
282    GtkWidget *searchdialog, *searchcheckbutton;          GtkWidget *searchdialog, *searchcheckbutton;
283    gboolean searchopen;          gboolean searchopen;
284    
285    searchdialog = gtk_widget_get_toplevel (GTK_WIDGET (togglebutton));          searchdialog = gtk_widget_get_toplevel (GTK_WIDGET (togglebutton));
286    searchcheckbutton = lookup_widget (searchdialog, "searchcheckbutton");          searchcheckbutton = lookup_widget (searchdialog, "searchcheckbutton");
287    searchopen =          searchopen =
288      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (searchcheckbutton));                  gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
289    if (searchopen)                                                (searchcheckbutton));
290      gtk_widget_set_sensitive (mainwindow, 1);          if (searchopen)
291    else                  gtk_widget_set_sensitive (mainwindow, 1);
292      gtk_widget_set_sensitive (mainwindow, 0);          else
293                    gtk_widget_set_sensitive (mainwindow, 0);
294  }  }
295    
296  gboolean  gboolean
297  on_searchdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_searchdialog_delete_event (GtkWidget * widget, GdkEvent * event,
298                                gpointer user_data)                                gpointer user_data)
299  {  {
300    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
301    return FALSE;          return FALSE;
302  }  }
303    
304  /* SEARCHRESULT DIALOG */  /* SEARCHRESULT DIALOG */
305  void  void
306  on_searchresultokbutton_clicked (GtkButton * button, gpointer user_data)  on_searchresultokbutton_clicked (GtkButton * button, gpointer user_data)
307  {  {
308    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
309  }  }
310    
311    
# Line 282  on_searchresultokbutton_clicked (GtkButt Line 313  on_searchresultokbutton_clicked (GtkButt
313  void  void
314  on_newlogokbutton_clicked (GtkButton * button, gpointer user_data)  on_newlogokbutton_clicked (GtkButton * button, gpointer user_data)
315  {  {
316    GtkWidget *newlogentry, *newlogdialog, *menubar, *log_editor_menu;          GtkWidget *newlogentry, *newlogdialog, *menubar, *log_editor_menu;
317    gchar *entry, *filename, *xlogbackupfile;          gchar *entry, *filename, *xlogbackupfile;
318    logtype *logwindow = NULL;          logtype *logwindow = NULL;
319    gint i;          gint i;
320    LOGDB *lp;          LOGDB *lp;
321    gboolean logopen = FALSE, logexist = FALSE;          gboolean logopen = FALSE, logexist = FALSE;
322    GString *logs;          GString *logs;
323    
324    newlogdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));          newlogdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
325    newlogentry = lookup_widget (newlogdialog, "newlogentry");          newlogentry = lookup_widget (newlogdialog, "newlogentry");
326    entry = gtk_editable_get_chars (GTK_EDITABLE (newlogentry), 0, -1);          entry = gtk_editable_get_chars (GTK_EDITABLE (newlogentry), 0, -1);
327    
328    if (strlen (entry) > 0)          if (strlen (entry) > 0)
329      {          {
330        for (i = 0; i < g_list_length (logwindowlist); i++)                  for (i = 0; i < g_list_length (logwindowlist); i++)
331          {                       /* see if the log is already open */                  {               /* see if the log is already open */
332            logwindow = g_list_nth_data (logwindowlist, i);                          logwindow = g_list_nth_data (logwindowlist, i);
333            if (g_ascii_strcasecmp (entry, logwindow->logname) == 0)                          if (g_ascii_strcasecmp (entry, logwindow->logname) ==
334              {                              0)
335                gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook), i);                          {
336                set_qsoframe (logwindow);                                  gtk_notebook_set_current_page (GTK_NOTEBOOK
337                logopen = TRUE;                                                                 (mainnotebook),
338                break;                                                                 i);
339              }                                  set_qsoframe (logwindow);
340          }                                  logopen = TRUE;
341        if (!logopen)                                  break;
342          {                       /* check if the log exists and open it */                          }
           filename = g_strconcat (entry, ".xlog", 0);  
           logs = getlogs (preferences.savedir, 0);  
           if (((logs->len) > 0) && (g_strrstr (logs->str, filename)))  
             {  
               logexist = TRUE;  
               filename =  
                 g_strconcat (preferences.savedir, G_DIR_SEPARATOR_S, entry,  
                              ".xlog", NULL);  
               lp = log_file_open (filename, TYPE_FLOG);  
               if (lp)  
                 {  
                   logwindow = openlog (lp, entry, state.logwindows++);  
                   log_file_qso_foreach (lp, fillin_clist, logwindow);  
                   log_file_close (lp);  
                   logwindowlist = g_list_append (logwindowlist, logwindow);  
                   gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook),  
                                          state.logwindows - 1);  
                   set_qsoframe (logwindow);  
                   xlogbackupfile = g_strconcat (filename, ".backup", NULL);  
                   savelog (logwindow, xlogbackupfile, TYPE_FLOG);  
                   g_free (xlogbackupfile);  
343                  }                  }
344                g_free (filename);                  if (!logopen)
345                g_string_free (logs, TRUE);                  {               /* check if the log exists and open it */
346              }                          filename = g_strconcat (entry, ".xlog", 0);
347          }                          logs = getlogs (preferences.savedir, 0);
348        if ((!logopen) && (!logexist))                          if (((logs->len) > 0)
349          {                       /* create a new log */                              && (g_strrstr (logs->str, filename)))
350            filename =                          {
351              g_strconcat (preferences.savedir, G_DIR_SEPARATOR_S, entry,                                  logexist = TRUE;
352                           ".xlog", NULL);                                  filename =
353            lp =                                          g_strconcat (preferences.savedir,
354              log_file_create (filename, TYPE_FLOG, qso_field_nr, qso_fields,                                                       G_DIR_SEPARATOR_S, entry,
355                               qso_widths);                                                       ".xlog", NULL);
356            if (lp)                                  lp = log_file_open (filename, TYPE_FLOG);
357              {                                  if (lp)
358                logwindow = openlog (lp, entry, state.logwindows++);                                  {
359                log_file_close (lp);                                          logwindow =
360                logwindowlist = g_list_append (logwindowlist, logwindow);                                                  openlog (lp, entry,
361                gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook),                                                           state.logwindows++);
362                                       state.logwindows - 1);                                          log_file_qso_foreach (lp,
363                set_qsoframe (logwindow);                                                                fillin_clist,
364              }                                                                logwindow);
365            g_free (filename);                                          log_file_close (lp);
366                                            logwindowlist =
367                                                    g_list_append (logwindowlist,
368                                                                   logwindow);
369                                            gtk_notebook_set_current_page
370                                                    (GTK_NOTEBOOK (mainnotebook),
371                                                     state.logwindows - 1);
372                                            set_qsoframe (logwindow);
373                                            xlogbackupfile =
374                                                    g_strconcat (filename,
375                                                                 ".backup", NULL);
376                                            savelog (logwindow, xlogbackupfile,
377                                                     TYPE_FLOG, 1,
378                                                     logwindow->qsos);
379                                            g_free (xlogbackupfile);
380                                    }
381                                    g_free (filename);
382                                    g_string_free (logs, TRUE);
383                            }
384                    }
385                    if ((!logopen) && (!logexist))
386                    {               /* create a new log */
387                            filename =
388                                    g_strconcat (preferences.savedir,
389                                                 G_DIR_SEPARATOR_S, entry,
390                                                 ".xlog", NULL);
391                            lp = log_file_create (filename, TYPE_FLOG,
392                                                  qso_field_nr, qso_fields,
393                                                  qso_widths);
394                            if (lp)
395                            {
396                                    logwindow =
397                                            openlog (lp, entry,
398                                                     state.logwindows++);
399                                    log_file_close (lp);
400                                    logwindowlist =
401                                            g_list_append (logwindowlist,
402                                                           logwindow);
403                                    gtk_notebook_set_current_page (GTK_NOTEBOOK
404                                                                   (mainnotebook),
405                                                                   state.
406                                                                   logwindows -
407                                                                   1);
408                                    set_qsoframe (logwindow);
409                            }
410                            g_free (filename);
411                    }
412                    g_free (entry);
413          }          }
       g_free (entry);  
     }  
414    
415    gtk_widget_destroy (newlogdialog);          gtk_widget_destroy (newlogdialog);
416    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
417    
418    /* fire up the logeditor */          /* fire up the logeditor */
419    if ((!logopen) && (!logexist))          if ((!logopen) && (!logexist))
420      {          {
421        gtk_widget_set_sensitive (mainwindow, 0);                  gtk_widget_set_sensitive (mainwindow, 0);
422        menubar = lookup_widget (mainwindow, "menubar");                  menubar = lookup_widget (mainwindow, "menubar");
423        log_editor_menu = lookup_widget (menubar, "log_editor");                  log_editor_menu = lookup_widget (menubar, "log_editor");
424        g_signal_emit_by_name (G_OBJECT (log_editor_menu), "activate");                  g_signal_emit_by_name (G_OBJECT (log_editor_menu),
425      }                                         "activate");
426            }
427  }  }
428    
429    
# Line 375  on_newlogokbutton_clicked (GtkButton * b Line 431  on_newlogokbutton_clicked (GtkButton * b
431  void  void
432  on_newlogcancelbutton_clicked (GtkButton * button, gpointer user_data)  on_newlogcancelbutton_clicked (GtkButton * button, gpointer user_data)
433  {  {
434    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
435    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
436  }  }
437    
438  /* new log dialog is deleted */  /* new log dialog is deleted */
# Line 384  gboolean Line 440  gboolean
440  on_newlogdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_newlogdialog_delete_event (GtkWidget * widget, GdkEvent * event,
441                                gpointer user_data)                                gpointer user_data)
442  {  {
443    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
444    return FALSE;          return FALSE;
445  }  }
446    
447  /* OPEN DIALOG */  /* OPEN DIALOG */
448  void  void
449  on_fileselection_ok_button_clicked (GtkButton * button, gpointer user_data)  on_fileselection_ok_button_clicked (GtkButton * button, gpointer user_data)
450  {  {
451    GtkWidget *fileselection, *filemenu, *menu, *item;          GtkWidget *fileselection, *filemenu, *menu, *item;
452    gchar *logn, *xlogbackupfile, *temp;          gchar *logn, *xlogbackupfile, *temp;
453    G_CONST_RETURN gchar* sellog;          G_CONST_RETURN gchar *sellog;
454    gchar *filen;          gchar *filen;
455    gboolean logexist = FALSE;          gboolean logexist = FALSE;
456    gint i, filetype;          gint i, filetype;
457    logtype *logwindow;          logtype *logwindow;
458    LOGDB *lp;          LOGDB *lp;
459    
460    fileselection = gtk_widget_get_toplevel (GTK_WIDGET (button));          fileselection = gtk_widget_get_toplevel (GTK_WIDGET (button));
461    
462    /* skip all if nothing filled in */          /* skip all if nothing filled in */
463    if (strlen(gtk_editable_get_chars(GTK_EDITABLE          if (strlen (gtk_editable_get_chars (GTK_EDITABLE
464            (GTK_FILE_SELECTION (fileselection)->selection_entry), 0,     -1)) > 0)                                              (GTK_FILE_SELECTION
465      {                                               (fileselection)->
466        filemenu = lookup_widget (fileselection, "filemenu");                                               selection_entry), 0, -1)) > 0)
467        menu = GTK_OPTION_MENU (filemenu)->menu;          {
468        item = gtk_menu_get_active (GTK_MENU (menu));                  filemenu = lookup_widget (fileselection, "filemenu");
469        /* skip old log format (0) */                  menu = GTK_OPTION_MENU (filemenu)->menu;
470        filetype = g_list_index (GTK_MENU_SHELL (menu)->children, item) + 1;                  item = gtk_menu_get_active (GTK_MENU (menu));
471                    /* skip old log format (0) */
472        /* don't free sellog */                  filetype =
473        sellog = gtk_file_selection_get_filename                          g_list_index (GTK_MENU_SHELL (menu)->children,
474                  (GTK_FILE_SELECTION (fileselection));                                        item) + 1;
475        filen = g_path_get_basename (sellog);  
476        logn = logname (filen);                  /* don't free sellog */
477            g_free(filen);                  sellog = gtk_file_selection_get_filename
478                            (GTK_FILE_SELECTION (fileselection));
479                    filen = g_path_get_basename (sellog);
480                    logn = logname (filen);
481                    g_free (filen);
482    
483            /* unselect any selected QSO */                  /* unselect any selected QSO */
484        for (i = 0; i < g_list_length (logwindowlist); i++)                  for (i = 0; i < g_list_length (logwindowlist); i++)
           {  
             logwindow = g_list_nth_data (logwindowlist, i);  
             gtk_tree_selection_unselect_all (gtk_tree_view_get_selection  
           (GTK_TREE_VIEW (logwindow->treeview)));  
           }  
   
       /* if log exist jump to the page in the notebook */  
       for (i = 0; i < g_list_length (logwindowlist); i++)  
         {  
           logwindow = g_list_nth_data (logwindowlist, i);  
           if (g_ascii_strcasecmp (logn, logwindow->logname) == 0)  
             {  
               gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook), i);  
               set_qsoframe (logwindow);  
               logexist = TRUE;  
               break;  
             }  
         }  
       if (!logexist)  
         {  
           lp = log_file_open (sellog, filetype);  
           if (lp)  
             {  
               logwindow = openlog (lp, logn, state.logwindows++);  
               log_file_qso_foreach (lp, fillin_clist, logwindow);  
               log_file_close (lp);  
                   lp->type = filetype;    
               if ((lp->type) == TYPE_FLOG)  
485                  {                  {
486                    xlogbackupfile = g_strconcat (sellog, ".backup", NULL);                          logwindow = g_list_nth_data (logwindowlist, i);
487            unlink(xlogbackupfile);                          gtk_tree_selection_unselect_all
488                backuplog ((gchar *)sellog, xlogbackupfile);                                  (gtk_tree_view_get_selection
489                    g_free (xlogbackupfile);                                   (GTK_TREE_VIEW (logwindow->treeview)));
490                  }                  }
491                logwindowlist = g_list_append (logwindowlist, logwindow);  
492                gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook),                  /* if log exist jump to the page in the notebook */
493                                       state.logwindows - 1);                  for (i = 0; i < g_list_length (logwindowlist); i++)
494                set_qsoframe (logwindow);                  {
495              }                          logwindow = g_list_nth_data (logwindowlist, i);
496                            if (g_ascii_strcasecmp (logn, logwindow->logname) ==
497                                0)
498                            {
499                                    gtk_notebook_set_current_page (GTK_NOTEBOOK
500                                                                   (mainnotebook),
501                                                                   i);
502                                    set_qsoframe (logwindow);
503                                    logexist = TRUE;
504                                    break;
505                            }
506                    }
507                    if (!logexist)
508                    {
509                            lp = log_file_open (sellog, filetype);
510                            if (lp)
511                            {
512                                    logwindow =
513                                            openlog (lp, logn,
514                                                     state.logwindows++);
515                                    log_file_qso_foreach (lp, fillin_clist,
516                                                          logwindow);
517                                    log_file_close (lp);
518                                    lp->type = filetype;
519                                    if ((lp->type) == TYPE_FLOG)
520                                    {
521                                            xlogbackupfile =
522                                                    g_strconcat (sellog,
523                                                                 ".backup", NULL);
524                                            unlink (xlogbackupfile);
525                                            backuplog ((gchar *) sellog,
526                                                       xlogbackupfile);
527                                            g_free (xlogbackupfile);
528                                    }
529                                    logwindowlist =
530                                            g_list_append (logwindowlist,
531                                                           logwindow);
532                                    gtk_notebook_set_current_page (GTK_NOTEBOOK
533                                                                   (mainnotebook),
534                                                                   state.
535                                                                   logwindows -
536                                                                   1);
537                                    set_qsoframe (logwindow);
538                            }
539                    }
540                    g_free (logn);
541          }          }
542        g_free (logn);          else
543      }          {
544    else                  temp = g_strdup_printf (_
545      {                                          ("No filename entered, open cancelled"));
546        temp = g_strdup_printf (_("No filename entered, open cancelled"));                  update_statusbar (temp);
547        update_statusbar (temp);                  g_free (temp);
548        g_free (temp);          }
549      }          gtk_widget_destroy (fileselection);
550    gtk_widget_destroy (fileselection);          gtk_widget_set_sensitive (mainwindow, 1);
   gtk_widget_set_sensitive (mainwindow, 1);  
551  }  }
552    
553    
# Line 480  void Line 556  void
556  on_fileselection_cancel_button_clicked (GtkButton * button,  on_fileselection_cancel_button_clicked (GtkButton * button,
557                                          gpointer user_data)                                          gpointer user_data)
558  {  {
559    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
560    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
561  }  }
562    
563  /* file selection dialog is deleted */  /* file selection dialog is deleted */
# Line 489  gboolean Line 565  gboolean
565  on_fileselection_delete_event (GtkWidget * widget, GdkEvent * event,  on_fileselection_delete_event (GtkWidget * widget, GdkEvent * event,
566                                 gpointer user_data)                                 gpointer user_data)
567  {  {
568    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
569    return FALSE;          return FALSE;
570  }  }
571    
572    
# Line 499  gboolean Line 575  gboolean
575  on_closedialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_closedialog_delete_event (GtkWidget * widget, GdkEvent * event,
576                               gpointer user_data)                               gpointer user_data)
577  {  {
578    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
579    return FALSE;          return FALSE;
580  }  }
581    
582    
583  void  void
584  on_closeokbutton_clicked (GtkButton * button, gpointer user_data)  on_closeokbutton_clicked (GtkButton * button, gpointer user_data)
585  {  {
586    logtype *logwindow;          logtype *logwindow;
587    gint page;          gint page;
588    
589    page = gtk_notebook_get_current_page (GTK_NOTEBOOK (mainnotebook));          page = gtk_notebook_get_current_page (GTK_NOTEBOOK (mainnotebook));
590    logwindow = g_list_nth_data (logwindowlist, page);          logwindow = g_list_nth_data (logwindowlist, page);
591    logwindowlist = g_list_remove (logwindowlist, logwindow);          logwindowlist = g_list_remove (logwindowlist, logwindow);
592    g_free (logwindow->logname);          g_free (logwindow->logname);
593    g_free (logwindow);          g_free (logwindow);
594    state.logwindows--;          state.logwindows--;
595    gtk_notebook_remove_page (GTK_NOTEBOOK (mainnotebook), page);          gtk_notebook_remove_page (GTK_NOTEBOOK (mainnotebook), page);
596    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
597    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
598  }  }
599    
600    
601  void  void
602  on_closecancelbutton_clicked (GtkButton * button, gpointer user_data)  on_closecancelbutton_clicked (GtkButton * button, gpointer user_data)
603  {  {
604    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
605    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
606  }  }
607    
608  /* LOG EDITOR */  /* LOG EDITOR */
# Line 534  gboolean Line 610  gboolean
610  on_logeditorwindow_delete_event (GtkWidget * widget, GdkEvent * event,  on_logeditorwindow_delete_event (GtkWidget * widget, GdkEvent * event,
611                                   gpointer user_data)                                   gpointer user_data)
612  {  {
613    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
614    return FALSE;          return FALSE;
615  }  }
616    
617  /* update logfields and return number of columns */  /* update logfields and return number of columns */
618  static gint  static gint
619  update_logfields (gint column, gint logfields[], gchar * showhide)  update_logfields (gint column, gint logfields[], gchar * showhide)
620  {  {
621    gint i, j;          gint i, j;
622    
623    for (i = 0; i < QSO_FIELDS; i++)          for (i = 0; i < QSO_FIELDS; i++)
     {  
       if (logfields[i] == column)  
         break;  
     }  
   /*  
    * If the column is not present, add it to the end of the array  
    * if 'Show' is selected  
    */  
   if (i == QSO_FIELDS)  
     {  
       if (g_ascii_strcasecmp (showhide, _("Show")) == 0)  
624          {          {
625            for (j = 0; j < QSO_FIELDS; j++)                  if (logfields[i] == column)
626              if (logfields[j] == 0)                          break;
627                {          }
628                  logfields[j] = column;          /*
629                  break;           * If the column is not present, add it to the end of the array
630                }           * if 'Show' is selected
631             */
632            if (i == QSO_FIELDS)
633            {
634                    if (g_ascii_strcasecmp (showhide, _("Show")) == 0)
635                    {
636                            for (j = 0; j < QSO_FIELDS; j++)
637                                    if (logfields[j] == 0)
638                                    {
639                                            logfields[j] = column;
640                                            break;
641                                    }
642                    }
643          }          }
     }  
644    
645    /*          /*
646     * If the column is present, remove from the array           * If the column is present, remove from the array
647     * if 'Hide' is selected           * if 'Hide' is selected
648     */           */
649    else          else
     {  
       if (g_ascii_strcasecmp (showhide, _("Hide")) == 0)  
650          {          {
651            logfields[i] = 0;                  if (g_ascii_strcasecmp (showhide, _("Hide")) == 0)
           for (j = 0; j < QSO_FIELDS; j++)  
             {  
               if (logfields[j] == 0)  
652                  {                  {
653                    if (logfields[j + 1] == 0)                          logfields[i] = 0;
654                      break;                          for (j = 0; j < QSO_FIELDS; j++)
655                    /* Shift '0' to the right */                          {
656                    logfields[j] = logfields[j + 1];                                  if (logfields[j] == 0)
657                    logfields[j + 1] = 0;                                  {
658                                            if (logfields[j + 1] == 0)
659                                                    break;
660                                            /* Shift '0' to the right */
661                                            logfields[j] = logfields[j + 1];
662                                            logfields[j + 1] = 0;
663                                    }
664                            }
665                  }                  }
             }  
666          }          }
     }  
667    
668    for (i = 0; i < QSO_FIELDS; i++)          for (i = 0; i < QSO_FIELDS; i++)
669      {          {
670        if (logfields[i] == 0)                  if (logfields[i] == 0)
671          break;                          break;
672      }          }
673    return (i);          return (i);
674  }  }
675    
676  static gint  static gint
677  compare_fields (void *f1, void *f2)  compare_fields (void *f1, void *f2)
678  {  {
679    gint *p = f1, *q = f2;          gint *p = f1, *q = f2;
680    if (*p - *q == *p)          if (*p - *q == *p)
681      return 0;                  return 0;
682    else          else
683      return (*p - *q);                  return (*p - *q);
684  }  }
685    
686    
687  void  void
688  on_logeditorokbutton_clicked (GtkButton * button, gpointer user_data)  on_logeditorokbutton_clicked (GtkButton * button, gpointer user_data)
689  {  {
690    logtype *logw;          logtype *logw;
691    GtkWidget *logeditor, *lecomboentry3, *lecomboentry9_10, *lecomboentry11,          GtkWidget *logeditor, *lecomboentry3, *lecomboentry9_10,
692      *lecomboentry12, *lecomboentry13, *lecomboentry14, *lecomboentry15,                  *lecomboentry11, *lecomboentry12, *lecomboentry13,
693      *lecomboentry16, *leentry15, *leentry16, *lecomboentry17;                  *lecomboentry14, *lecomboentry15, *lecomboentry16, *leentry15,
694    GtkWidget *unknownlabel1, *unknownlabel2;                  *leentry16, *lecomboentry17;
695    gchar *temp;          GtkWidget *unknownlabel1, *unknownlabel2;
696    gint i, columns, fields[QSO_FIELDS];          gchar *temp;
697    GtkTreeViewColumn *column;          gint i, columns, fields[QSO_FIELDS];
698            GtkTreeViewColumn *column;
699    logw = g_list_nth_data (logwindowlist,  
700          gtk_notebook_get_current_page (GTK_NOTEBOOK(mainnotebook)));          logw = g_list_nth_data (logwindowlist,
701                                    gtk_notebook_get_current_page (GTK_NOTEBOOK
702    for (i = 0; i < logw->columns; i++)                                                                 (mainnotebook)));
703      fields[i] = logw->logfields[i];  
704    for (i = logw->columns; i < QSO_FIELDS; i++)          for (i = 0; i < logw->columns; i++)
705      fields[i] = 0;                  fields[i] = logw->logfields[i];
706            for (i = logw->columns; i < QSO_FIELDS; i++)
707    logeditor = gtk_widget_get_toplevel (GTK_WIDGET (button));                  fields[i] = 0;
708    
709    lecomboentry3 = lookup_widget (logeditor, "lecomboentry3");          logeditor = gtk_widget_get_toplevel (GTK_WIDGET (button));
710    temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry3), 0, -1);  
711    column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), GMTEND);          lecomboentry3 = lookup_widget (logeditor, "lecomboentry3");
712    if (g_ascii_strcasecmp (temp, _("Hide")) == 0)          temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry3), 0, -1);
713      gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);          column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
714    else                                             GMTEND);
715      gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);          if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
716    columns = update_logfields (GMTEND, fields, temp);                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
717                                                      (column), FALSE);
718    lecomboentry9_10 = lookup_widget (logeditor, "lecomboentry9_10");          else
719    temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry9_10), 0, -1);                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
720    if (g_ascii_strcasecmp (temp, _("Hide")) == 0)                                                    (column), TRUE);
721      {          columns = update_logfields (GMTEND, fields, temp);
722            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), QSLOUT);  
723        gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);          lecomboentry9_10 = lookup_widget (logeditor, "lecomboentry9_10");
724            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), QSLIN);          temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry9_10), 0,
725        gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);                                         -1);
726      }          if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
727    else          {
728      {                  column = gtk_tree_view_get_column (GTK_TREE_VIEW
729            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), QSLOUT);                                                     (logw->treeview), QSLOUT);
730        gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
731            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), QSLIN);                                                    (column), FALSE);
732        gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);                  column = gtk_tree_view_get_column (GTK_TREE_VIEW
733      }                                                     (logw->treeview), QSLIN);
734    columns = update_logfields (QSLOUT, fields, temp);                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
735    columns = update_logfields (QSLIN, fields, temp);                                                    (column), FALSE);
736            }
737    lecomboentry11 = lookup_widget (logeditor, "lecomboentry11");          else
738    temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry11), 0, -1);          {
739    column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), POWER);                  column = gtk_tree_view_get_column (GTK_TREE_VIEW
740    if (g_ascii_strcasecmp (temp, _("Hide")) == 0)                                                     (logw->treeview), QSLOUT);
741      gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
742    else                                                    (column), TRUE);
743      gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);                  column = gtk_tree_view_get_column (GTK_TREE_VIEW
744    columns = update_logfields (POWER, fields, temp);                                                     (logw->treeview), QSLIN);
745                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
746    lecomboentry12 = lookup_widget (logeditor, "lecomboentry12");                                                    (column), TRUE);
747    temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry12), 0, -1);          }
748    column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), NAME);          columns = update_logfields (QSLOUT, fields, temp);
749    if (g_ascii_strcasecmp (temp, _("Hide")) == 0)          columns = update_logfields (QSLIN, fields, temp);
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (NAME, fields, temp);  
   
   lecomboentry13 = lookup_widget (logeditor, "lecomboentry13");  
   temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry13), 0, -1);  
   column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), QTH);  
   if (g_ascii_strcasecmp (temp, _("Hide")) == 0)  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (QTH, fields, temp);  
   
   lecomboentry14 = lookup_widget (logeditor, "lecomboentry14");  
   temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry14), 0, -1);  
   column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), LOCATOR);  
   if (g_ascii_strcasecmp (temp, _("Hide")) == 0)  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (LOCATOR, fields, temp);  
   
   lecomboentry15 = lookup_widget (logeditor, "lecomboentry15");  
   temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry15), 0, -1);  
   column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), U1);  
   if (g_ascii_strcasecmp (temp, _("Hide")) == 0)  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (U1, fields, temp);  
   
   lecomboentry16 = lookup_widget (logeditor, "lecomboentry16");  
   temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry16), 0, -1);  
   column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), U2);  
   if (g_ascii_strcasecmp (temp, _("Hide")) == 0)  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (U2, fields, temp);  
   
   lecomboentry17 = lookup_widget (logeditor, "lecomboentry17");  
   temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry17), 0, -1);  
   column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), REMARKS);  
   if (g_ascii_strcasecmp (temp, _("Hide")) == 0)  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), FALSE);  
   else  
     gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), TRUE);  
   columns = update_logfields (REMARKS, fields, temp);  
   
   for (i = 0; i < QSO_FIELDS; i++)  
     if (fields[i] != logw->logfields[i])  
       break;  
750    
751    qsort (fields, QSO_FIELDS, sizeof (gint), (compar_callback_fn) compare_fields);          lecomboentry11 = lookup_widget (logeditor, "lecomboentry11");
752    if (i < QSO_FIELDS)          temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry11), 0, -1);
753      {          column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
754        for (i = 0; i < QSO_FIELDS; i++)                                             POWER);
755          logw->logfields[i] = fields[i];          if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
756        logw->columns = columns;                  gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
757      }                                                    (column), FALSE);
758            else
759                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
760                                                      (column), TRUE);
761            columns = update_logfields (POWER, fields, temp);
762    
763            lecomboentry12 = lookup_widget (logeditor, "lecomboentry12");
764            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry12), 0, -1);
765            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
766                                               NAME);
767            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
768                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
769                                                      (column), FALSE);
770            else
771                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
772                                                      (column), TRUE);
773            columns = update_logfields (NAME, fields, temp);
774    
775            lecomboentry13 = lookup_widget (logeditor, "lecomboentry13");
776            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry13), 0, -1);
777            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
778                                               QTH);
779            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
780                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
781                                                      (column), FALSE);
782            else
783                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
784                                                      (column), TRUE);
785            columns = update_logfields (QTH, fields, temp);
786    
787            lecomboentry14 = lookup_widget (logeditor, "lecomboentry14");
788            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry14), 0, -1);
789            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
790                                               LOCATOR);
791            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
792                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
793                                                      (column), FALSE);
794            else
795                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
796                                                      (column), TRUE);
797            columns = update_logfields (LOCATOR, fields, temp);
798    
799            lecomboentry15 = lookup_widget (logeditor, "lecomboentry15");
800            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry15), 0, -1);
801            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
802                                               U1);
803            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
804                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
805                                                      (column), FALSE);
806            else
807                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
808                                                      (column), TRUE);
809            columns = update_logfields (U1, fields, temp);
810    
811            lecomboentry16 = lookup_widget (logeditor, "lecomboentry16");
812            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry16), 0, -1);
813            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
814                                               U2);
815            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
816                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
817                                                      (column), FALSE);
818            else
819                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
820                                                      (column), TRUE);
821            columns = update_logfields (U2, fields, temp);
822    
823            lecomboentry17 = lookup_widget (logeditor, "lecomboentry17");
824            temp = gtk_editable_get_chars (GTK_EDITABLE (lecomboentry17), 0, -1);
825            column = gtk_tree_view_get_column (GTK_TREE_VIEW (logw->treeview),
826                                               REMARKS);
827            if (g_ascii_strcasecmp (temp, _("Hide")) == 0)
828                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
829                                                      (column), FALSE);
830            else
831                    gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
832                                                      (column), TRUE);
833            columns = update_logfields (REMARKS, fields, temp);
834    
835            for (i = 0; i < QSO_FIELDS; i++)
836                    if (fields[i] != logw->logfields[i])
837                            break;
838    
839            qsort (fields, QSO_FIELDS, sizeof (gint),
840                   (compar_callback_fn) compare_fields);
841            if (i < QSO_FIELDS)
842            {
843                    for (i = 0; i < QSO_FIELDS; i++)
844                            logw->logfields[i] = fields[i];
845                    logw->columns = columns;
846            }
847    
848    leentry15 = lookup_widget (logeditor, "leentry15");          leentry15 = lookup_widget (logeditor, "leentry15");
849    leentry16 = lookup_widget (logeditor, "leentry16");          leentry16 = lookup_widget (logeditor, "leentry16");
850    temp = gtk_editable_get_chars (GTK_EDITABLE (leentry15), 0, -1);          temp = gtk_editable_get_chars (GTK_EDITABLE (leentry15), 0, -1);
851    if (g_ascii_strcasecmp (temp, preferences.freefield1) != 0)          if (g_ascii_strcasecmp (temp, preferences.freefield1) != 0)
852      {          {
853        if (strlen (temp) == 0) temp = g_strdup ("UNKNOWN");                  if (strlen (temp) == 0)
854        preferences.freefield1 = g_strdup (temp);                          temp = g_strdup ("UNKNOWN");
855        unknownlabel1 = lookup_widget (mainwindow, "unknownlabel1");                  preferences.freefield1 = g_strdup (temp);
856        gtk_label_set_text (GTK_LABEL (unknownlabel1), temp);                  unknownlabel1 = lookup_widget (mainwindow, "unknownlabel1");
857            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), U1);                  gtk_label_set_text (GTK_LABEL (unknownlabel1), temp);
858        gtk_tree_view_column_set_title  (column, preferences.freefield1);                  column = gtk_tree_view_get_column (GTK_TREE_VIEW
859      }                                                     (logw->treeview), U1);
860    temp = gtk_editable_get_chars (GTK_EDITABLE (leentry16), 0, -1);                  gtk_tree_view_column_set_title (column,
861    if (g_ascii_strcasecmp (temp, preferences.freefield2) != 0)                                                  preferences.freefield1);
862      {          }
863        if (strlen (temp) == 0) temp = g_strdup ("UNKNOWN");          temp = gtk_editable_get_chars (GTK_EDITABLE (leentry16), 0, -1);
864        preferences.freefield2 = g_strdup (temp);          if (g_ascii_strcasecmp (temp, preferences.freefield2) != 0)
865        unknownlabel2 = lookup_widget (mainwindow, "unknownlabel2");          {
866        gtk_label_set_text (GTK_LABEL (unknownlabel2), temp);                  if (strlen (temp) == 0)
867            column = gtk_tree_view_get_column (GTK_TREE_VIEW(logw->treeview), U2);                          temp = g_strdup ("UNKNOWN");
868        gtk_tree_view_column_set_title  (column, preferences.freefield2);                  preferences.freefield2 = g_strdup (temp);
869      }                  unknownlabel2 = lookup_widget (mainwindow, "unknownlabel2");
870                    gtk_label_set_text (GTK_LABEL (unknownlabel2), temp);
871                    column = gtk_tree_view_get_column (GTK_TREE_VIEW
872                                                       (logw->treeview), U2);
873                    gtk_tree_view_column_set_title (column,
874                                                    preferences.freefield2);
875            }
876    
877    g_free (temp);          g_free (temp);
878    gtk_widget_destroy (logeditor);          gtk_widget_destroy (logeditor);
879    set_qsoframe (logw);          set_qsoframe (logw);
880    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
881  }  }
882    
883    
884  void  void
885  on_logeditorcancelbutton_clicked (GtkButton * button, gpointer user_data)  on_logeditorcancelbutton_clicked (GtkButton * button, gpointer user_data)
886  {  {
887    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
888    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
889  }  }
890    
891  /* SAVE AS DIALOG */  /* SAVE AS DIALOG */
892  void  void
893  on_saveasok_button_clicked (GtkButton * button, gpointer user_data)  on_saveasok_button_clicked (GtkButton * button, gpointer user_data)
894  {  {
895    GtkWidget *saveasdialog, *saveasmenu, *menu, *item, *savewarningdialog,          GtkWidget *saveasdialog, *saveasmenu, *menu, *item,
896      *savewarninglabel;                  *savewarningdialog, *savewarninglabel, *lowqsoentry,
897    gchar *temp, *rev;                  *highqsoentry;
898    gint index;          gchar *temp, *rev;
899    logtype *logwindow;          gint index;
900    gboolean warning = FALSE;          logtype *logwindow;
901            gboolean warning = FALSE;
902    
903    saveasdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));    saveasdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
904    saveasmenu = lookup_widget (saveasdialog, "saveasmenu");    saveasmenu = lookup_widget (saveasdialog, "saveasmenu");
905      lowqsoentry = lookup_widget (saveasdialog, "lowqsoentry");
906      highqsoentry = lookup_widget (saveasdialog, "highqsoentry");
907    menu = GTK_OPTION_MENU (saveasmenu)->menu;    menu = GTK_OPTION_MENU (saveasmenu)->menu;
908    item = gtk_menu_get_active (GTK_MENU (menu));    item = gtk_menu_get_active (GTK_MENU (menu));
909    index = g_list_index (GTK_MENU_SHELL (menu)->children, item);    index = g_list_index (GTK_MENU_SHELL (menu)->children, item);
910    
911    switch (index) {          switch (index)
912          case 0:          {
913                  globtype = TYPE_FLOG;    case 0:
914                  break;      type = TYPE_FLOG;
915          case 1:      break;
916                  globtype = TYPE_ADIF;    case 1:
917                  break;      type = TYPE_ADIF;
918          case 2:      break;
919                  globtype = TYPE_CABRILLO;    case 2:
920                  break;      type = TYPE_CABRILLO;
921          case 3:      break;
922                  globtype = TYPE_TRLOG;    case 3:
923                  break;      type = TYPE_TRLOG;
924          case 4:      break;
925                  globtype = TYPE_EDI;          case 4:
926                  break;      type = TYPE_EDI;
927          default:      break;
928                  globtype = 0;    default:
929    }      type = 0;
930            }
931    
932    globtemp =    logfile = g_strdup (gtk_file_selection_get_filename
933      g_strdup (gtk_file_selection_get_filename          (GTK_FILE_SELECTION (saveasdialog)));
934                (GTK_FILE_SELECTION (saveasdialog)));    rev = g_strdup (logfile);
   rev = g_strdup (globtemp);  
935    g_strreverse (rev);    g_strreverse (rev);
936    if (!g_ascii_strncasecmp (rev, "/", 1))    if (!g_ascii_strncasecmp (rev, "/", 1))
937      {    {
938        temp = g_strdup_printf (_("No filename entered, log not saved"));      temp = g_strdup_printf (_("No filename entered, log not saved"));
939        update_statusbar (temp);      update_statusbar (temp);
940      }    }
941    else if (globtype == 0)    else if (type == 0)
942      {    {
943        temp = g_strdup_printf (_("Unsupported log type, log not saved"));          temp = g_strdup_printf (_("Unsupported log type, log not saved"));
944        update_statusbar (temp);      update_statusbar (temp);
945      }    }
946    else    else
947      {    {
948        if (!fileexist (globtemp))            temp = gtk_editable_get_chars (GTK_EDITABLE (lowqsoentry), 0, -1);
949          {            lowqso = atoi (temp);
950            logwindow = g_list_nth_data (logwindowlist,            temp = gtk_editable_get_chars (GTK_EDITABLE (highqsoentry), 0, -1);
951                                         gtk_notebook_get_current_page            highqso = atoi (temp);
952                                         (GTK_NOTEBOOK (mainnotebook)));            if (!fileexist (logfile))
953            savelog (logwindow, globtemp, globtype);            {
954            temp = g_strdup_printf (_("Log saved to %s"), globtemp);                  logwindow = g_list_nth_data (logwindowlist,
955            update_statusbar (temp);          gtk_notebook_get_current_page (GTK_NOTEBOOK (mainnotebook)));
956          }                  savelog (logwindow, logfile, type, lowqso, highqso);
957        else                  temp = g_strdup_printf (_("Log saved to %s"),   logfile);
958          {          update_statusbar (temp);
959            savewarningdialog = create_savewarningdialog ();      }
960            savewarninglabel =      else
961              lookup_widget (savewarningdialog, "savewarninglabel");      {
962            temp =          savewarningdialog = create_savewarningdialog ();
963              g_strdup_printf (_("%s already exist, do want to overwrite it?"),          savewarninglabel = lookup_widget (savewarningdialog, "savewarninglabel");
964                               globtemp);          temp = g_strdup_printf (_("%s already exist, do want to overwrite it?"),
965            gtk_label_set_text (GTK_LABEL (savewarninglabel), temp);          logfile);
966            gtk_widget_show (savewarningdialog);                  gtk_label_set_text (GTK_LABEL (savewarninglabel), temp);
967            warning = TRUE;                  gtk_widget_show (savewarningdialog);
968          }                  warning = TRUE;
969      }          }
970      }
971    g_free (temp);    g_free (temp);
972    g_free (rev);    g_free (rev);
973    
974    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
975    if (!warning)    if (!warning) gtk_widget_set_sensitive (mainwindow, 1);
     gtk_widget_set_sensitive (mainwindow, 1);  
976  }  }
977    
978  /* delete save as dialog */  /* delete save as dialog */
# Line 859  gboolean Line 980  gboolean
980  on_saveasdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_saveasdialog_delete_event (GtkWidget * widget, GdkEvent * event,
981                                gpointer user_data)                                gpointer user_data)
982  {  {
983    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
984    return FALSE;          return FALSE;
985  }  }
986    
987    
# Line 868  on_saveasdialog_delete_event (GtkWidget Line 989  on_saveasdialog_delete_event (GtkWidget
989  void  void
990  on_saveas_cancel_button_clicked (GtkButton * button, gpointer user_data)  on_saveas_cancel_button_clicked (GtkButton * button, gpointer user_data)
991  {  {
992    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
993    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
994  }  }
995    
996    
# Line 877  on_saveas_cancel_button_clicked (GtkButt Line 998  on_saveas_cancel_button_clicked (GtkButt
998  void  void
999  on_dupecheckokbutton_clicked (GtkButton * button, gpointer user_data)  on_dupecheckokbutton_clicked (GtkButton * button, gpointer user_data)
1000  {  {
1001    GtkWidget *dupecheckdialog, *dupecheckthisradiobutton, *dupelistdialog,          GtkWidget *dupecheckdialog, *dupecheckthisradiobutton,
1002      *dupecheckstatusbar, *dupecheckprogressbar, *dupecheckbuttonmode,                  *dupelistdialog, *dupecheckstatusbar, *dupecheckprogressbar,
1003          *dupecheckbuttonband, *duperesultdialog,                  *dupecheckbuttonmode, *dupecheckbuttonband, *duperesultdialog,
1004          *dupedialogvbox, *dupescrolledwindow, *dupetreeview;                  *dupedialogvbox, *dupescrolledwindow, *dupetreeview;
1005    GList *dupelist = NULL;          GList *dupelist = NULL;
1006    logtype *logwindow;          logtype *logwindow;
1007    gint i, page, savedpage, pages, row = 0, step, duperow = 0;          gint i, page, savedpage, pages, row = 0, step, duperow = 0;
1008    gchar *logn, *prevlogn, *nr, *prevnr, *date, *gmt, *callsign, *band,          gchar *logn, *prevlogn, *nr, *prevnr, *date, *gmt, *callsign, *band,
1009      *mode, *temp, *str, *dupestr;                  *mode, *temp, *str, *dupestr;
1010    gchar **dupe = NULL;          gchar **dupe = NULL;
1011    gboolean dupefound = FALSE, valid = FALSE;          gboolean dupefound = FALSE, valid = FALSE;
1012    GtkTreeStore *dupemodel;          GtkTreeStore *dupemodel;
1013    GtkCellRenderer *duperenderer;          GtkCellRenderer *duperenderer;
1014    GtkTreeViewColumn *dupecolumn;          GtkTreeViewColumn *dupecolumn;
1015    GtkTreeIter dupeiter, iter;          GtkTreeIter dupeiter, iter;
1016    GtkTreeModel *model;          GtkTreeModel *model;
1017    GObject *selection;          GObject *selection;
1018    
1019    dupe = g_new0 (gchar *, 7);          dupe = g_new0 (gchar *, 7);
1020    for (i = 0; i < 7; i++)          for (i = 0; i < 7; i++)
1021      dupe[i] = g_new0 (gchar, 100);                  dupe[i] = g_new0 (gchar, 100);
1022    
1023    dupecheckdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));          dupecheckdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
1024    dupecheckthisradiobutton = lookup_widget (dupecheckdialog,          dupecheckthisradiobutton = lookup_widget (dupecheckdialog,
1025                                              "dupecheckthisradiobutton");                                                    "dupecheckthisradiobutton");
1026    dupecheckbuttonmode =          dupecheckbuttonmode =
1027      lookup_widget (dupecheckdialog, "dupecheckbuttonmode");                  lookup_widget (dupecheckdialog, "dupecheckbuttonmode");
1028    dupecheckbuttonband =          dupecheckbuttonband =
1029      lookup_widget (dupecheckdialog, "dupecheckbuttonband");                  lookup_widget (dupecheckdialog, "dupecheckbuttonband");
1030    dupecheckstatusbar = lookup_widget (dupecheckdialog, "dupecheckstatusbar");          dupecheckstatusbar =
1031    dupecheckprogressbar =                  lookup_widget (dupecheckdialog, "dupecheckstatusbar");
1032      lookup_widget (dupecheckdialog, "dupecheckprogressbar");          dupecheckprogressbar =
1033    gtk_statusbar_pop (GTK_STATUSBAR (dupecheckstatusbar), 1);                  lookup_widget (dupecheckdialog, "dupecheckprogressbar");
1034    gtk_statusbar_push (GTK_STATUSBAR (dupecheckstatusbar), 1,          gtk_statusbar_pop (GTK_STATUSBAR (dupecheckstatusbar), 1);
1035                        _("Searching ..."));          gtk_statusbar_push (GTK_STATUSBAR (dupecheckstatusbar), 1,
1036                                _("Searching ..."));
1037    if (gtk_toggle_button_get_active  
1038        (GTK_TOGGLE_BUTTON (dupecheckthisradiobutton)))          if (gtk_toggle_button_get_active
1039      state.dupecheck = 0;              (GTK_TOGGLE_BUTTON (dupecheckthisradiobutton)))
1040    else                  state.dupecheck = 0;
1041      state.dupecheck = 1;          else
1042    state.notdupecheckmode =                  state.dupecheck = 1;
1043      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dupecheckbuttonmode));          state.notdupecheckmode =
1044    state.notdupecheckband =                  gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1045      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dupecheckbuttonband));                                                (dupecheckbuttonmode));
1046            state.notdupecheckband =
1047    dupelistdialog = create_dupelistdialog ();                  gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1048                                                  (dupecheckbuttonband));
1049    /* create a treeview */  
1050    dupescrolledwindow = gtk_scrolled_window_new (NULL, NULL);          dupelistdialog = create_dupelistdialog ();
1051    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(dupescrolledwindow),  
1052      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);          /* create a treeview */
1053    gtk_widget_show (dupescrolledwindow);          dupescrolledwindow = gtk_scrolled_window_new (NULL, NULL);
1054    dupedialogvbox = lookup_widget(dupelistdialog, "dupedialogvbox");          gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
1055    gtk_box_pack_start (GTK_BOX (dupedialogvbox), dupescrolledwindow,                                          (dupescrolledwindow),
1056          TRUE, TRUE, 0);                                          GTK_POLICY_AUTOMATIC,
1057    gtk_box_reorder_child (GTK_BOX (dupedialogvbox), dupescrolledwindow, 0);                                          GTK_POLICY_AUTOMATIC);
1058    dupemodel = gtk_tree_store_new (7, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,          gtk_widget_show (dupescrolledwindow);
1059      G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);          dupedialogvbox = lookup_widget (dupelistdialog, "dupedialogvbox");
1060    dupetreeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(dupemodel));          gtk_box_pack_start (GTK_BOX (dupedialogvbox), dupescrolledwindow,
1061    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(dupemodel),                              TRUE, TRUE, 0);
1062          4, GTK_SORT_ASCENDING);          gtk_box_reorder_child (GTK_BOX (dupedialogvbox), dupescrolledwindow,
1063    g_object_unref (G_OBJECT (dupemodel));                                 0);
1064    gtk_widget_show (dupetreeview);          dupemodel =
1065    gtk_container_add (GTK_CONTAINER (dupescrolledwindow), dupetreeview);                  gtk_tree_store_new (7, G_TYPE_STRING, G_TYPE_STRING,
1066                                        G_TYPE_STRING, G_TYPE_STRING,
1067    /* add callback for selecting a row */                                      G_TYPE_STRING, G_TYPE_STRING,
1068    selection = G_OBJECT (gtk_tree_view_get_selection                                      G_TYPE_STRING);
1069      (GTK_TREE_VIEW (dupetreeview)));          dupetreeview =
1070    gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),                  gtk_tree_view_new_with_model (GTK_TREE_MODEL (dupemodel));
1071      GTK_SELECTION_SINGLE);          gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dupemodel),
1072    g_signal_connect (selection, "changed",                                                4, GTK_SORT_ASCENDING);
1073      G_CALLBACK (on_dupetreeview_select_row), NULL);          g_object_unref (G_OBJECT (dupemodel));
1074            gtk_widget_show (dupetreeview);
1075    /* add columns */          gtk_container_add (GTK_CONTAINER (dupescrolledwindow), dupetreeview);
1076    duperenderer = gtk_cell_renderer_text_new ();  
1077    dupecolumn = gtk_tree_view_column_new_with_attributes          /* add callback for selecting a row */
1078      ("LOG", duperenderer, "text", 0, NULL);          selection = G_OBJECT (gtk_tree_view_get_selection
1079    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),                                (GTK_TREE_VIEW (dupetreeview)));
1080      GTK_TREE_VIEW_COLUMN_GROW_ONLY );          gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
1081    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);                                       GTK_SELECTION_SINGLE);
1082            g_signal_connect (selection, "changed",
1083    duperenderer = gtk_cell_renderer_text_new ();                            G_CALLBACK (on_dupetreeview_select_row), NULL);
1084    dupecolumn = gtk_tree_view_column_new_with_attributes  
1085      ("NR", duperenderer, "text", 1, NULL);          /* add columns */
1086    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),          duperenderer = gtk_cell_renderer_text_new ();
1087      GTK_TREE_VIEW_COLUMN_GROW_ONLY );          dupecolumn = gtk_tree_view_column_new_with_attributes
1088    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);                  ("LOG", duperenderer, "text", 0, NULL);
1089            gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1090    duperenderer = gtk_cell_renderer_text_new ();                                           GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1091    dupecolumn = gtk_tree_view_column_new_with_attributes          gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1092      ("DATE", duperenderer, "text", 2, NULL);                                       dupecolumn);
1093    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),  
1094      GTK_TREE_VIEW_COLUMN_GROW_ONLY );          duperenderer = gtk_cell_renderer_text_new ();
1095    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);          dupecolumn = gtk_tree_view_column_new_with_attributes
1096                    ("NR", duperenderer, "text", 1, NULL);
1097    duperenderer = gtk_cell_renderer_text_new ();          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1098    dupecolumn = gtk_tree_view_column_new_with_attributes                                           GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1099      ("GMT", duperenderer, "text", 3, NULL);          gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1100    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),                                       dupecolumn);
1101      GTK_TREE_VIEW_COLUMN_GROW_ONLY );  
1102    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);          duperenderer = gtk_cell_renderer_text_new ();
1103            dupecolumn = gtk_tree_view_column_new_with_attributes
1104    duperenderer = gtk_cell_renderer_text_new ();                  ("DATE", duperenderer, "text", 2, NULL);
1105    dupecolumn = gtk_tree_view_column_new_with_attributes          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1106      ("CALL", duperenderer, "text", 4, NULL);                                           GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1107    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),          gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1108      GTK_TREE_VIEW_COLUMN_GROW_ONLY );                                       dupecolumn);
1109    gtk_tree_view_column_set_sort_column_id (dupecolumn, 4);  
1110    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);          duperenderer = gtk_cell_renderer_text_new ();
1111            dupecolumn = gtk_tree_view_column_new_with_attributes
1112    duperenderer = gtk_cell_renderer_text_new ();                  ("GMT", duperenderer, "text", 3, NULL);
1113    dupecolumn = gtk_tree_view_column_new_with_attributes          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1114      ("BAND", duperenderer, "text", 5, NULL);                                           GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1115    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),          gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1116      GTK_TREE_VIEW_COLUMN_GROW_ONLY );                                       dupecolumn);
1117    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);  
1118            duperenderer = gtk_cell_renderer_text_new ();
1119    duperenderer = gtk_cell_renderer_text_new ();          dupecolumn = gtk_tree_view_column_new_with_attributes
1120    dupecolumn = gtk_tree_view_column_new_with_attributes                  ("CALL", duperenderer, "text", 4, NULL);
1121      ("MODE", duperenderer, "text", 6, NULL);          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1122    gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(dupecolumn),                                           GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1123      GTK_TREE_VIEW_COLUMN_GROW_ONLY );          gtk_tree_view_column_set_sort_column_id (dupecolumn, 4);
1124    gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview), dupecolumn);          gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1125                                         dupecolumn);
1126    
1127            duperenderer = gtk_cell_renderer_text_new ();
1128            dupecolumn = gtk_tree_view_column_new_with_attributes
1129                    ("BAND", duperenderer, "text", 5, NULL);
1130            gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1131                                             GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1132            gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1133                                         dupecolumn);
1134    
1135            duperenderer = gtk_cell_renderer_text_new ();
1136            dupecolumn = gtk_tree_view_column_new_with_attributes
1137                    ("MODE", duperenderer, "text", 6, NULL);
1138            gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
1139                                             GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1140            gtk_tree_view_append_column (GTK_TREE_VIEW (dupetreeview),
1141                                         dupecolumn);
1142    
1143    /* all or this page */          /* all or this page */
1144    if (state.dupecheck == 0)          if (state.dupecheck == 0)
1145      {          {
1146        page = gtk_notebook_get_current_page (GTK_NOTEBOOK (mainnotebook));                  page = gtk_notebook_get_current_page (GTK_NOTEBOOK
1147        pages = page + 1;                                                        (mainnotebook));
1148      }                  pages = page + 1;
1149    else          }
1150      {          else
1151        page = 0;          {
1152        pages = g_list_length (logwindowlist);                  page = 0;
1153      }                  pages = g_list_length (logwindowlist);
1154            }
1155    
1156    savedpage = page;          savedpage = page;
1157    while (page < pages)          while (page < pages)
1158      { /* make a string consisting of callbandmode */          {                       /* make a string consisting of callbandmode */
1159        logwindow = g_list_nth_data (logwindowlist, page);                  logwindow = g_list_nth_data (logwindowlist, page);
1160            model = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                  model = gtk_tree_view_get_model (GTK_TREE_VIEW
1161            valid = gtk_tree_model_get_iter_first (model, &iter);                                                   (logwindow->treeview));
1162        while (valid)                  valid = gtk_tree_model_get_iter_first (model, &iter);
1163            {                  while (valid)
1164            gtk_tree_model_get (model, &iter, CALL, &temp, -1);                  {
1165            if (!state.notdupecheckband)                          gtk_tree_model_get (model, &iter, CALL, &temp, -1);
1166              {                          if (!state.notdupecheckband)
1167                    gtk_tree_model_get (model, &iter, BAND, &band, -1);                          {
1168                str = findband (g_strdup (band));                                  gtk_tree_model_get (model, &iter, BAND, &band,
1169                temp = g_strconcat (temp, str, NULL);                                                      -1);
1170                g_free (str);                                  str = findband (g_strdup (band));
1171              }                                  temp = g_strconcat (temp, str, NULL);
1172            if (!state.notdupecheckmode)                                  g_free (str);
1173              {                          }
1174                gtk_tree_model_get (model, &iter, MODE, &mode, -1);                          if (!state.notdupecheckmode)
1175                temp = g_strconcat (temp, mode, NULL);                          {
1176              }                                  gtk_tree_model_get (model, &iter, MODE, &mode,
1177            dupelist = g_list_append (dupelist, temp);                                                      -1);
1178            valid = gtk_tree_model_iter_next (model, &iter);                                  temp = g_strconcat (temp, mode, NULL);
1179            }                          }
1180        page++;                          dupelist = g_list_append (dupelist, temp);
1181      }                          valid = gtk_tree_model_iter_next (model, &iter);
1182                    }
1183                    page++;
1184            }
1185    
1186    page = savedpage;          page = savedpage;
1187    while (page < pages)          while (page < pages)
1188      { /* check the list against the logs */          {                       /* check the list against the logs */
1189        logwindow = g_list_nth_data (logwindowlist, page);                  logwindow = g_list_nth_data (logwindowlist, page);
1190            model = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                  model = gtk_tree_view_get_model (GTK_TREE_VIEW
1191            valid = gtk_tree_model_get_iter_first (model, &iter);                                                   (logwindow->treeview));
1192        while (valid)                  valid = gtk_tree_model_get_iter_first (model, &iter);
1193            {                  while (valid)
1194            if (row++ % 50 == 0)                  {
1195              {                          if (row++ % 50 == 0)
1196                    gtk_progress_bar_pulse(GTK_PROGRESS_BAR(dupecheckprogressbar));                          {
1197                while (gtk_events_pending ())     gtk_main_iteration ();                                  gtk_progress_bar_pulse (GTK_PROGRESS_BAR
1198              }                                                          (dupecheckprogressbar));
1199            gtk_tree_model_get (model, &iter, CALL, &temp, -1);                                  while (gtk_events_pending ())
1200            if (!state.notdupecheckband)                                          gtk_main_iteration ();
1201              {                          }
1202                gtk_tree_model_get (model, &iter, BAND, &band, -1);                          gtk_tree_model_get (model, &iter, CALL, &temp, -1);
1203                str = findband (g_strdup (band));                          if (!state.notdupecheckband)
1204                temp = g_strconcat (temp, str, NULL);                          {
1205                g_free (str);                                  gtk_tree_model_get (model, &iter, BAND, &band,
1206              }                                                      -1);
1207            if (!state.notdupecheckmode)                                  str = findband (g_strdup (band));
1208              {                                  temp = g_strconcat (temp, str, NULL);
1209                gtk_tree_model_get (model, &iter, MODE, &mode, -1);                                  g_free (str);
1210                temp = g_strconcat (temp, mode, NULL);                          }
1211              }                          if (!state.notdupecheckmode)
1212            dupestr = g_strdup (temp);                          {
1213            for (step = 0; step < logwindow->qsos; step++)                                  gtk_tree_model_get (model, &iter, MODE, &mode,
1214              {                                                      -1);
1215                if (g_ascii_strcasecmp                                  temp = g_strconcat (temp, mode, NULL);
1216                          (dupestr, g_list_nth_data (dupelist, step)) == 0)                          }
1217                    { /* dupe found */                          dupestr = g_strdup (temp);
1218                    gtk_tree_model_get (model, &iter, NR, &nr, -1);                          for (step = 0; step < logwindow->qsos; step++)
1219                    if ((logwindow->qsos) - step != atoi (nr))                          {
1220                      {                                  if (g_ascii_strcasecmp
1221                        dupe[0] = g_strdup (logwindow->logname);                                      (dupestr,
1222                        dupe[1] = g_strdup (nr);                                       g_list_nth_data (dupelist, step)) == 0)
1223                        gtk_tree_model_get (model, &iter, DATE, &date, -1);                                  {       /* dupe found */
1224                        dupe[2] = g_strdup (date);                                          gtk_tree_model_get (model, &iter, NR,
1225                        gtk_tree_model_get (model, &iter, GMT, &gmt, -1);                                                              &nr, -1);
1226                        dupe[3] = g_strdup (gmt);                                          if ((logwindow->qsos) - step !=
1227                        gtk_tree_model_get (model, &iter, CALL, &callsign, -1);                                              atoi (nr))
1228                        dupe[4] = g_strdup (callsign);                                          {
1229                        gtk_tree_model_get (model, &iter, BAND, &band, -1);                                                  dupe[0] =
1230                        dupe[5] = g_strdup (band);                                                          g_strdup (logwindow->
1231                        gtk_tree_model_get (model, &iter, MODE, &mode, -1);                                                                    logname);
1232                        dupe[6] = g_strdup (mode);                                                  dupe[1] = g_strdup (nr);
1233                            gtk_tree_store_prepend (GTK_TREE_STORE(dupemodel),                                                  gtk_tree_model_get (model,
1234                                  &dupeiter, NULL);                                                                      &iter,
1235                            gtk_tree_store_set (GTK_TREE_STORE(dupemodel), &dupeiter,                                                                      DATE,
1236                                  0, dupe[0], 1, dupe[1], 2, dupe[2],                                                                      &date,
1237                                  3, dupe[3], 4, dupe[4], 5, dupe[5],                                                                      -1);
1238                                  6, dupe[6], -1);                                                  dupe[2] = g_strdup (date);
1239                        dupefound = TRUE;                                                  gtk_tree_model_get (model,
1240                      }                                                                      &iter,
1241                    }                                                                      GMT, &gmt,
1242                duperow++;                                                                      -1);
1243              }                                                  dupe[3] = g_strdup (gmt);
1244                  valid = gtk_tree_model_iter_next (model, &iter);                                                  gtk_tree_model_get (model,
1245            }                                                                      &iter,
1246        page++;                                                                      CALL,
1247      }                                                                      &callsign,
1248                                                                        -1);
1249                                                    dupe[4] = g_strdup (callsign);
1250                                                    gtk_tree_model_get (model,
1251                                                                        &iter,
1252                                                                        BAND,
1253                                                                        &band,
1254                                                                        -1);
1255                                                    dupe[5] = g_strdup (band);
1256                                                    gtk_tree_model_get (model,
1257                                                                        &iter,
1258                                                                        MODE,
1259                                                                        &mode,
1260                                                                        -1);
1261                                                    dupe[6] = g_strdup (mode);
1262                                                    gtk_tree_store_prepend
1263                                                            (GTK_TREE_STORE
1264                                                             (dupemodel),
1265                                                             &dupeiter, NULL);
1266                                                    gtk_tree_store_set
1267                                                            (GTK_TREE_STORE
1268                                                             (dupemodel),
1269                                                             &dupeiter, 0,
1270                                                             dupe[0], 1, dupe[1],
1271                                                             2, dupe[2], 3,
1272                                                             dupe[3], 4, dupe[4],
1273                                                             5, dupe[5], 6,
1274                                                             dupe[6], -1);
1275                                                    dupefound = TRUE;
1276                                            }
1277                                    }
1278                                    duperow++;
1279                            }
1280                            valid = gtk_tree_model_iter_next (model, &iter);
1281                    }
1282                    page++;
1283            }
1284    
1285    g_list_free (dupelist);          g_list_free (dupelist);
1286    g_free (temp);          g_free (temp);
1287    for (i = 0; i < 7; i++)          for (i = 0; i < 7; i++)
1288      g_free (dupe[i]);                  g_free (dupe[i]);
1289    g_free (dupe);          g_free (dupe);
1290    
1291    gtk_widget_destroy (dupecheckdialog);          gtk_widget_destroy (dupecheckdialog);
1292      
1293    i = 0;          i = 0;
1294    if (dupefound)          if (dupefound)
1295      { /* remove double entries */          {                       /* remove double entries */
1296            model = gtk_tree_view_get_model (GTK_TREE_VIEW(dupetreeview));                  model = gtk_tree_view_get_model (GTK_TREE_VIEW
1297            valid = gtk_tree_model_get_iter_first (model, &iter);                                                   (dupetreeview));
1298        while (valid)                  valid = gtk_tree_model_get_iter_first (model, &iter);
1299            {                  while (valid)
                 gtk_tree_model_get (model, &iter, 0, &logn, -1);  
                 gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);  
                 dupeiter = iter;  
                 valid = gtk_tree_model_iter_next (model, &dupeiter);  
                   if (valid)  
1300                  {                  {
1301                  gtk_tree_model_get (model, &dupeiter, 0, &prevlogn, -1);                          gtk_tree_model_get (model, &iter, 0, &logn, -1);
1302                  gtk_tree_model_get (model, &dupeiter, NR + 1, &prevnr, -1);                          gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);
1303                    if ((g_ascii_strcasecmp (prevnr, nr) == 0)                          dupeiter = iter;
1304                          && (g_ascii_strcasecmp (prevlogn, logn) == 0))                          valid = gtk_tree_model_iter_next (model, &dupeiter);
1305                gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);                          if (valid)
1306                  }                          {
1307                  valid = gtk_tree_model_iter_next (model, &iter);                                  gtk_tree_model_get (model, &dupeiter, 0,
1308            }                                                      &prevlogn, -1);
1309        gtk_widget_show (dupelistdialog);                                  gtk_tree_model_get (model, &dupeiter, NR + 1,
1310        gtk_widget_set_sensitive (mainwindow, 1);                                                      &prevnr, -1);
1311      }                                  if ((g_ascii_strcasecmp (prevnr, nr) == 0)
1312    else                                      && (g_ascii_strcasecmp (prevlogn, logn) ==
1313      {                                          0))
1314        duperesultdialog = create_duperesultdialog ();                                          gtk_tree_store_remove (GTK_TREE_STORE
1315        gtk_widget_destroy (dupelistdialog);                                                                 (model),
1316        gtk_widget_show (duperesultdialog);                                                                 &iter);
1317      }                          }
1318                            valid = gtk_tree_model_iter_next (model, &iter);
1319                    }
1320                    gtk_widget_show (dupelistdialog);
1321                    gtk_widget_set_sensitive (mainwindow, 1);
1322            }
1323            else
1324            {
1325                    duperesultdialog = create_duperesultdialog ();
1326                    gtk_widget_destroy (dupelistdialog);
1327                    gtk_widget_show (duperesultdialog);
1328            }
1329  }  }
1330    
1331    
# Line 1150  gboolean Line 1334  gboolean
1334  on_dupecheckdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_dupecheckdialog_delete_event (GtkWidget * widget, GdkEvent * event,
1335                                   gpointer user_data)                                   gpointer user_data)
1336  {  {
1337    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1338    return FALSE;          return FALSE;
1339  }  }
1340    
1341  /* cancel dupe check */  /* cancel dupe check */
1342  void  void
1343  on_dupecheckcancelbutton_clicked (GtkButton * button, gpointer user_data)  on_dupecheckcancelbutton_clicked (GtkButton * button, gpointer user_data)
1344  {  {
1345    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1346    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1347  }  }
1348    
1349    
# Line 1167  on_dupecheckcancelbutton_clicked (GtkBut Line 1351  on_dupecheckcancelbutton_clicked (GtkBut
1351  void  void
1352  on_dupelistokbutton_clicked (GtkButton * button, gpointer user_data)  on_dupelistokbutton_clicked (GtkButton * button, gpointer user_data)
1353  {  {
1354    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1355  }  }
1356    
1357  /* entry is selected in the duperesult list, select corresponding entry in  /* entry is selected in the duperesult list, select corresponding entry in
# Line 1175  on_dupelistokbutton_clicked (GtkButton * Line 1359  on_dupelistokbutton_clicked (GtkButton *
1359    
1360    
1361  void  void
1362  on_dupetreeview_select_row (GtkTreeSelection *selection, gpointer user_data)  on_dupetreeview_select_row (GtkTreeSelection * selection, gpointer user_data)
1363  {  {
1364    gchar *nr, *lognr, *logn;          gchar *nr, *lognr, *logn;
1365    guint i = 0;          guint i = 0;
1366    logtype *logwindow = NULL;          logtype *logwindow = NULL;
1367    gboolean qsofound = FALSE, valid = FALSE;          gboolean qsofound = FALSE, valid = FALSE;
1368    GtkTreeModel *model, *logmodel = NULL;          GtkTreeModel *model, *logmodel = NULL;
1369    GtkTreeIter iter, logiter;          GtkTreeIter iter, logiter;
1370    GtkTreeSelection *logselection;          GtkTreeSelection *logselection;
1371    GtkTreePath *logpath;          GtkTreePath *logpath;
1372    
1373    if (gtk_tree_selection_get_selected (selection, &model, &iter))          if (gtk_tree_selection_get_selected (selection, &model, &iter))
1374    {          {
1375      gtk_tree_model_get (model, &iter, 0, &logn, -1);                  gtk_tree_model_get (model, &iter, 0, &logn, -1);
1376      gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);                  gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);
1377            
1378      for (i = 0; i < g_list_length (logwindowlist); i++)                  for (i = 0; i < g_list_length (logwindowlist); i++)
1379      {                  {
1380          logwindow = g_list_nth_data (logwindowlist, i);                          logwindow = g_list_nth_data (logwindowlist, i);
1381          logmodel = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                          logmodel =
1382              valid = gtk_tree_model_get_iter_first (logmodel, &logiter);                                  gtk_tree_view_get_model (GTK_TREE_VIEW
1383          while (valid)                                                           (logwindow->
1384            {                                                            treeview));
1385                  gtk_tree_model_get (logmodel, &logiter, NR, &lognr, -1);                          valid = gtk_tree_model_get_iter_first (logmodel,
1386              if ((g_ascii_strcasecmp (nr, lognr) == 0)                                                                 &logiter);
1387                  && (g_ascii_strcasecmp (logn, logwindow->logname) == 0))                          while (valid)
1388                {                          {
1389                  qsofound = TRUE;                                  gtk_tree_model_get (logmodel, &logiter, NR,
1390                  break;                                                      &lognr, -1);
1391                }                                  if ((g_ascii_strcasecmp (nr, lognr) == 0)
1392                  valid = gtk_tree_model_iter_next (logmodel, &logiter);                                      &&
1393            }                                      (g_ascii_strcasecmp
1394        if (qsofound)     break;                                       (logn, logwindow->logname) == 0))
1395      }                                  {
1396      if (qsofound)                                          qsofound = TRUE;
1397      {                                          break;
1398        gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook), i);                                  }
1399            logselection = gtk_tree_view_get_selection                                  valid = gtk_tree_model_iter_next (logmodel,
1400                  (GTK_TREE_VIEW(logwindow->treeview));                                                                    &logiter);
1401            gtk_tree_selection_select_iter (logselection, &logiter);                          }
1402        logpath = gtk_tree_model_get_path (logmodel, &logiter);                          if (qsofound)
1403            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(logwindow->treeview),                                  break;
1404          logpath, NULL, TRUE, 0.5, 0.0);                  }
1405        gtk_tree_path_free (logpath);                  if (qsofound)
1406      }                  {
1407    }                          gtk_notebook_set_current_page (GTK_NOTEBOOK
1408                                                           (mainnotebook), i);
1409                            logselection =
1410                                    gtk_tree_view_get_selection (GTK_TREE_VIEW
1411                                                                 (logwindow->
1412                                                                  treeview));
1413                            gtk_tree_selection_select_iter (logselection,
1414                                                            &logiter);
1415                            logpath =
1416                                    gtk_tree_model_get_path (logmodel, &logiter);
1417                            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW
1418                                                          (logwindow->treeview),
1419                                                          logpath, NULL, TRUE,
1420                                                          0.5, 0.0);
1421                            gtk_tree_path_free (logpath);
1422                    }
1423            }
1424  }  }
1425    
1426    
# Line 1228  on_dupetreeview_select_row (GtkTreeSelec Line 1428  on_dupetreeview_select_row (GtkTreeSelec
1428  void  void
1429  on_duperesultdialogokbutton_clicked (GtkButton * button, gpointer user_data)  on_duperesultdialogokbutton_clicked (GtkButton * button, gpointer user_data)
1430  {  {
1431    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1432    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1433  }  }
1434    
1435  /* delete the duperesult dialog */  /* delete the duperesult dialog */
# Line 1237  gboolean Line 1437  gboolean
1437  on_duperesultdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_duperesultdialog_delete_event (GtkWidget * widget, GdkEvent * event,
1438                                    gpointer user_data)                                    gpointer user_data)
1439  {  {
1440    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1441    return FALSE;          return FALSE;
1442  }  }
1443    
1444    
# Line 1247  gboolean Line 1447  gboolean
1447  on_savewarningdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_savewarningdialog_delete_event (GtkWidget * widget, GdkEvent * event,
1448                                     gpointer user_data)                                     gpointer user_data)
1449  {  {
1450    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1451    return FALSE;          return FALSE;
1452  }  }
1453    
1454    
1455  void  void
1456  on_savewarningokbutton_clicked (GtkButton * button, gpointer user_data)  on_savewarningokbutton_clicked (GtkButton * button, gpointer user_data)
1457  {  {
1458    gchar *temp;          gchar *temp;
1459    logtype *logwindow;          logtype *logwindow;
1460    
1461    logwindow = g_list_nth_data (logwindowlist,          logwindow = g_list_nth_data (logwindowlist,
1462                                 gtk_notebook_get_current_page (GTK_NOTEBOOK                                       gtk_notebook_get_current_page
1463                                                                (mainnotebook)));                                       (GTK_NOTEBOOK (mainnotebook)));
1464    savelog (logwindow, globtemp, globtype);          savelog (logwindow, logfile, type, lowqso, highqso);
1465    temp = g_strdup_printf (_("Log saved to %s"), globtemp);          temp = g_strdup_printf (_("Log saved to %s"), logfile);
1466    update_statusbar (temp);          update_statusbar (temp);
1467    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1468    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1469  }  }
1470    
1471    
1472  void  void
1473  on_savewarningcancelbutton_clicked (GtkButton * button, gpointer user_data)  on_savewarningcancelbutton_clicked (GtkButton * button, gpointer user_data)
1474  {  {
1475    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1476    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1477  }  }
1478    
1479    
# Line 1282  gboolean Line 1482  gboolean
1482  on_defaultsdialog_delete_event (GtkWidget * widget, GdkEvent * event,  on_defaultsdialog_delete_event (GtkWidget * widget, GdkEvent * event,
1483                                  gpointer user_data)                                  gpointer user_data)
1484  {  {
1485    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1486    return FALSE;          return FALSE;
1487  }  }
1488    
1489    
1490  void  void
1491  on_defaultsokbutton_clicked (GtkButton * button, gpointer user_data)  on_defaultsokbutton_clicked (GtkButton * button, gpointer user_data)
1492  {  {
1493    GtkWidget *defaultsmhzentry, *defaultsmodeentry, *defaultstxrstentry,          GtkWidget *defaultsmhzentry, *defaultsmodeentry, *defaultstxrstentry,
1494      *defaultsrxrstentry, *defaultspowerentry, *defaultsdialog,                  *defaultsrxrstentry, *defaultspowerentry, *defaultsdialog,
1495      *defaultsfreefield1entry, *defaultsfreefield2entry, *defaultsremarksentry;                  *defaultsfreefield1entry, *defaultsfreefield2entry,
1496    gchar *temp;                  *defaultsremarksentry;
1497            gchar *temp;
1498    defaultsdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));  
1499    defaultsmhzentry = lookup_widget (defaultsdialog, "defaultsmhzentry");          defaultsdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
1500    defaultsmodeentry = lookup_widget (defaultsdialog, "defaultsmodeentry");          defaultsmhzentry = lookup_widget (defaultsdialog, "defaultsmhzentry");
1501    defaultstxrstentry = lookup_widget (defaultsdialog, "defaultstxrstentry");          defaultsmodeentry =
1502    defaultsrxrstentry = lookup_widget (defaultsdialog, "defaultsrxrstentry");                  lookup_widget (defaultsdialog, "defaultsmodeentry");
1503    defaultspowerentry = lookup_widget (defaultsdialog, "defaultspowerentry");          defaultstxrstentry =
1504    defaultsfreefield1entry =                  lookup_widget (defaultsdialog, "defaultstxrstentry");
1505      lookup_widget (defaultsdialog, "defaultsfreefield1entry");          defaultsrxrstentry =
1506    defaultsfreefield2entry =                  lookup_widget (defaultsdialog, "defaultsrxrstentry");
1507      lookup_widget (defaultsdialog, "defaultsfreefield2entry");          defaultspowerentry =
1508    defaultsremarksentry =                  lookup_widget (defaultsdialog, "defaultspowerentry");
1509      lookup_widget (defaultsdialog, "defaultsremarksentry");          defaultsfreefield1entry =
1510                    lookup_widget (defaultsdialog, "defaultsfreefield1entry");
1511    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsmhzentry), 0, -1);          defaultsfreefield2entry =
1512    if (strlen (temp) == 0)                  lookup_widget (defaultsdialog, "defaultsfreefield2entry");
1513      preferences.defaultmhz = g_strdup ("?");          defaultsremarksentry =
1514    else if (g_ascii_strcasecmp (preferences.defaultmhz, temp))                  lookup_widget (defaultsdialog, "defaultsremarksentry");
1515      preferences.defaultmhz = g_strdup (temp);  
1516    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsmodeentry), 0, -1);          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsmhzentry), 0,
1517    if (strlen (temp) == 0)                                         -1);
1518      preferences.defaultmode = g_strdup ("?");          if (strlen (temp) == 0)
1519    else if (g_ascii_strcasecmp (preferences.defaultmode, temp))                  preferences.defaultmhz = g_strdup ("?");
1520      preferences.defaultmode = g_strdup (temp);          else if (g_ascii_strcasecmp (preferences.defaultmhz, temp))
1521    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultstxrstentry), 0, -1);                  preferences.defaultmhz = g_strdup (temp);
1522    if (strlen (temp) == 0)          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsmodeentry), 0,
1523      preferences.defaulttxrst = g_strdup ("?");                                         -1);
1524    else if (g_ascii_strcasecmp (preferences.defaulttxrst, temp))          if (strlen (temp) == 0)
1525      preferences.defaulttxrst = g_strdup (temp);                  preferences.defaultmode = g_strdup ("?");
1526    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsrxrstentry), 0, -1);          else if (g_ascii_strcasecmp (preferences.defaultmode, temp))
1527    if (strlen (temp) == 0)                  preferences.defaultmode = g_strdup (temp);
1528      preferences.defaultrxrst = g_strdup ("?");          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultstxrstentry), 0,
1529    else if (g_ascii_strcasecmp (preferences.defaultrxrst, temp))                                         -1);
1530      preferences.defaultrxrst = g_strdup (temp);          if (strlen (temp) == 0)
1531    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultspowerentry), 0, -1);                  preferences.defaulttxrst = g_strdup ("?");
1532    if (strlen (temp) == 0)          else if (g_ascii_strcasecmp (preferences.defaulttxrst, temp))
1533      preferences.defaultpower = g_strdup ("?");                  preferences.defaulttxrst = g_strdup (temp);
1534    else if (g_ascii_strcasecmp (preferences.defaultpower, temp))          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsrxrstentry), 0,
1535      preferences.defaultpower = g_strdup (temp);                                         -1);
1536    temp =          if (strlen (temp) == 0)
1537      gtk_editable_get_chars (GTK_EDITABLE (defaultsfreefield1entry), 0, -1);                  preferences.defaultrxrst = g_strdup ("?");
1538    if (strlen (temp) == 0)          else if (g_ascii_strcasecmp (preferences.defaultrxrst, temp))
1539      preferences.defaultfreefield1 = g_strdup ("?");                  preferences.defaultrxrst = g_strdup (temp);
1540    else if (g_ascii_strcasecmp (preferences.defaultfreefield1, temp))          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultspowerentry), 0,
1541      preferences.defaultfreefield1 = g_strdup (temp);                                         -1);
1542    temp =          if (strlen (temp) == 0)
1543      gtk_editable_get_chars (GTK_EDITABLE (defaultsfreefield2entry), 0, -1);                  preferences.defaultpower = g_strdup ("?");
1544    if (strlen (temp) == 0)          else if (g_ascii_strcasecmp (preferences.defaultpower, temp))
1545      preferences.defaultfreefield2 = g_strdup ("?");                  preferences.defaultpower = g_strdup (temp);
1546    else if (g_ascii_strcasecmp (preferences.defaultfreefield2, temp))          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsfreefield1entry),
1547      preferences.defaultfreefield2 = g_strdup (temp);                                         0, -1);
1548    temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsremarksentry), 0, -1);          if (strlen (temp) == 0)
1549    if (strlen (temp) == 0)                  preferences.defaultfreefield1 = g_strdup ("?");
1550      preferences.defaultremarks = g_strdup ("?");          else if (g_ascii_strcasecmp (preferences.defaultfreefield1, temp))
1551    else if (g_ascii_strcasecmp (preferences.defaultremarks, temp))                  preferences.defaultfreefield1 = g_strdup (temp);
1552      preferences.defaultremarks = g_strdup (temp);          temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsfreefield2entry),
1553                                           0, -1);
1554    g_free (temp);          if (strlen (temp) == 0)
1555    gtk_widget_destroy (defaultsdialog);                  preferences.defaultfreefield2 = g_strdup ("?");
1556    gtk_widget_set_sensitive (mainwindow, 1);          else if (g_ascii_strcasecmp (preferences.defaultfreefield2, temp))
1557                    preferences.defaultfreefield2 = g_strdup (temp);
1558            temp = gtk_editable_get_chars (GTK_EDITABLE (defaultsremarksentry), 0,
1559                                           -1);
1560            if (strlen (temp) == 0)
1561                    preferences.defaultremarks = g_strdup ("?");
1562            else if (g_ascii_strcasecmp (preferences.defaultremarks, temp))
1563                    preferences.defaultremarks = g_strdup (temp);
1564    
1565            g_free (temp);
1566            gtk_widget_destroy (defaultsdialog);
1567            gtk_widget_set_sensitive (mainwindow, 1);
1568  }  }
1569    
1570    
1571  void  void
1572  on_defaultscancelbutton_clicked (GtkButton * button, gpointer user_data)  on_defaultscancelbutton_clicked (GtkButton * button, gpointer user_data)
1573  {  {
1574    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1575    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1576  }  }
1577    
1578  /* WORKED B4 DIALOG */  /* WORKED B4 DIALOG */
1579  void  void
1580  on_b4treeview_select_row (GtkTreeSelection *selection, gpointer user_data)  on_b4treeview_select_row (GtkTreeSelection * selection, gpointer user_data)
1581  {  {
1582    gchar *nr, *lognr, *logn;          gchar *nr, *lognr, *logn;
1583    guint i = 0;          guint i = 0;
1584    logtype *logwindow = NULL;          logtype *logwindow = NULL;
1585    gboolean qsofound = FALSE, valid = FALSE;          gboolean qsofound = FALSE, valid = FALSE;
1586    GtkTreeModel *model, *logmodel = NULL;          GtkTreeModel *model, *logmodel = NULL;
1587    GtkTreeIter iter, logiter;          GtkTreeIter iter, logiter;
1588    GtkTreeSelection *logselection;          GtkTreeSelection *logselection;
1589    GtkTreePath *logpath;          GtkTreePath *logpath;
1590    
1591    if (gtk_tree_selection_get_selected (selection, &model, &iter))          if (gtk_tree_selection_get_selected (selection, &model, &iter))
1592    {          {
1593      gtk_tree_model_get (model, &iter, 0, &logn, -1);                  gtk_tree_model_get (model, &iter, 0, &logn, -1);
1594      gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);                  gtk_tree_model_get (model, &iter, NR + 1, &nr, -1);
1595            
1596      for (i = 0; i < g_list_length (logwindowlist); i++)                  for (i = 0; i < g_list_length (logwindowlist); i++)
1597      {                  {
1598          logwindow = g_list_nth_data (logwindowlist, i);                          logwindow = g_list_nth_data (logwindowlist, i);
1599          logmodel = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                          logmodel =
1600              valid = gtk_tree_model_get_iter_first (logmodel, &logiter);                                  gtk_tree_view_get_model (GTK_TREE_VIEW
1601          while (valid)                                                           (logwindow->
1602            {                                                            treeview));
1603                  gtk_tree_model_get (logmodel, &logiter, NR, &lognr, -1);                          valid = gtk_tree_model_get_iter_first (logmodel,
1604              if ((g_ascii_strcasecmp (nr, lognr) == 0)                                                                 &logiter);
1605                  && (g_ascii_strcasecmp (logn, logwindow->logname) == 0))                          while (valid)
1606                {                          {
1607                  qsofound = TRUE;                                  gtk_tree_model_get (logmodel, &logiter, NR,
1608                  break;                                                      &lognr, -1);
1609                }                                  if ((g_ascii_strcasecmp (nr, lognr) == 0)
1610                  valid = gtk_tree_model_iter_next (logmodel, &logiter);                                      &&
1611            }                                      (g_ascii_strcasecmp
1612        if (qsofound)     break;                                       (logn, logwindow->logname) == 0))
1613      }                                  {
1614      if (qsofound)                                          qsofound = TRUE;
1615      {                                          break;
1616        gtk_notebook_set_current_page (GTK_NOTEBOOK (mainnotebook), i);                                  }
1617            logselection = gtk_tree_view_get_selection                                  valid = gtk_tree_model_iter_next (logmodel,
1618                  (GTK_TREE_VIEW(logwindow->treeview));                                                                    &logiter);
1619            gtk_tree_selection_select_iter (logselection, &logiter);                          }
1620        logpath = gtk_tree_model_get_path (logmodel, &logiter);                          if (qsofound)
1621            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(logwindow->treeview),                                  break;
1622          logpath, NULL, TRUE, 0.5, 0.0);                  }
1623        gtk_tree_path_free (logpath);                  if (qsofound)
1624      }                  {
1625    }                          gtk_notebook_set_current_page (GTK_NOTEBOOK
1626                                                           (mainnotebook), i);
1627                            logselection =
1628                                    gtk_tree_view_get_selection (GTK_TREE_VIEW
1629                                                                 (logwindow->
1630                                                                  treeview));
1631                            gtk_tree_selection_select_iter (logselection,
1632                                                            &logiter);
1633                            logpath =
1634                                    gtk_tree_model_get_path (logmodel, &logiter);
1635                            gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW
1636                                                          (logwindow->treeview),
1637                                                          logpath, NULL, TRUE,
1638                                                          0.5, 0.0);
1639                            gtk_tree_path_free (logpath);
1640                    }
1641            }
1642  }  }
1643    
1644  gboolean  gboolean
1645  on_b4dialog_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data)  on_b4dialog_delete_event (GtkWidget * widget, GdkEvent * event,
1646                              gpointer user_data)
1647  {  {
1648    gtk_widget_hide (b4dialog);          gtk_widget_hide (b4dialog);
1649    return TRUE; /* do not destroy */          return TRUE;            /* do not destroy */
1650  }  }
1651    
1652    
1653  /* DIALOGS DIALOG */  /* DIALOGS DIALOG */
1654  gboolean  gboolean
1655  on_dialogsdialog_delete_event(GtkWidget * widget, GdkEvent * event,  on_dialogsdialog_delete_event (GtkWidget * widget, GdkEvent * event,
1656                                          gpointer user_data)                                 gpointer user_data)
1657  {  {
1658    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1659    return FALSE;          return FALSE;
1660  }  }
1661    
1662    
1663  void  void
1664  on_dialogsokbutton_clicked(GtkButton * button, gpointer user_data)  on_dialogsokbutton_clicked (GtkButton * button, gpointer user_data)
1665  {  {
1666    GtkWidget *dialogsdialog, *checkbutton, *b4treeview;          GtkWidget *dialogsdialog, *checkbutton, *b4treeview;
1667    gchar *widgetname, **states;          gchar *widgetname, **states;
1668    gboolean check;          gboolean check;
1669    gint i;          gint i;
1670    GtkTreeViewColumn *column;          GtkTreeViewColumn *column;
1671    
1672    states = g_new0 (gchar *, 20);          states = g_new0 (gchar *, 20);
1673    dialogsdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));          dialogsdialog = gtk_widget_get_toplevel (GTK_WIDGET (button));
1674    
1675    for (i = 0; i < 19; i++)          for (i = 0; i < 19; i++)
1676    { /* look up name of the  button and get it's togglestate */          {                       /* look up name of the  button and get it's togglestate */
1677      widgetname = g_strdup_printf("b4%d", i);                  widgetname = g_strdup_printf ("b4%d", i);
1678      checkbutton = lookup_widget(dialogsdialog, widgetname);                  checkbutton = lookup_widget (dialogsdialog, widgetname);
1679      check = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton));                  check = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
1680      if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))                                                        (checkbutton));
1681          {                  if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))
1682            b4treeview = lookup_widget(b4dialog, "b4treeview");                  {
1683            column = gtk_tree_view_get_column (GTK_TREE_VIEW(b4treeview), i);                          b4treeview = lookup_widget (b4dialog, "b4treeview");
1684            gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN(column), check);                          column = gtk_tree_view_get_column (GTK_TREE_VIEW
1685                                                               (b4treeview), i);
1686                            gtk_tree_view_column_set_visible (GTK_TREE_VIEW_COLUMN
1687                                                              (column), check);
1688                    }
1689                    states[i] = g_strdup (check ? "1" : "0");
1690                    g_free (widgetname);
1691          }          }
1692      states[i] = g_strdup(check ? "1" : "0");          states[19] = NULL;      /* terminator for g_strjoinv */
1693      g_free(widgetname);          preferences.b4columns = g_strjoinv (",", states);
   }  
   states[19] = NULL; /* terminator for g_strjoinv */  
   preferences.b4columns = g_strjoinv (",", states);  
1694    
1695    for (i = 0; i < 19; i++)          for (i = 0; i < 19; i++)
1696      g_free(states[i]);                  g_free (states[i]);
1697    g_free(states);          g_free (states);
1698    
1699    gtk_widget_destroy (dialogsdialog);          gtk_widget_destroy (dialogsdialog);
1700    if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))          if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))
1701      gtk_widget_set_sensitive (b4dialog, 1);                  gtk_widget_set_sensitive (b4dialog, 1);
1702    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1703  }  }
1704    
1705    
1706  void  void
1707  on_dialogscancelbutton_clicked(GtkButton * button, gpointer user_data)  on_dialogscancelbutton_clicked (GtkButton * button, gpointer user_data)
1708  {  {
1709    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1710    if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))          if (b4dialog && GTK_WIDGET_VISIBLE (b4dialog))
1711      gtk_widget_set_sensitive (b4dialog, 1);                  gtk_widget_set_sensitive (b4dialog, 1);
1712    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1713  }  }
1714    
1715  /* TRACE DIALOG */  /* TRACE DIALOG */
1716  static void stop_tracing(void)  static void
1717    stop_tracing (void)
1718  {  {
1719  #if WANT_HAMLIB  #if WANT_HAMLIB
1720    gint hamlibresult;          gint hamlibresult;
1721    
1722    stop_hamlib();          stop_hamlib ();
1723    g_source_remove (tracetimer);          g_source_remove (tracetimer);
1724    fclose (finfo.fd);          fclose (finfo.fd);
1725          dup2 (saved_fd, STDERR_FILENO);          dup2 (saved_fd, STDERR_FILENO);
1726          close (saved_fd);          close (saved_fd);
1727    stderr = fdopen (STDERR_FILENO, "w");          stderr = fdopen (STDERR_FILENO, "w");
1728    hamlibresult = start_hamlib (preferences.radio, preferences.device,          hamlibresult = start_hamlib (preferences.radio, preferences.device,
1729      RIG_DEBUG_NONE, preferences.polltime);                                       RIG_DEBUG_NONE, preferences.polltime);
1730  #endif  /* WANT_HAMLIB */  #endif /* WANT_HAMLIB */
1731  }  }
1732    
1733  gboolean  gboolean
1734  on_tracedialog_delete_event (GtkWidget *widget, GdkEvent *event,  on_tracedialog_delete_event (GtkWidget * widget, GdkEvent * event,
1735    gpointer user_data)                               gpointer user_data)
1736  {  {
1737    stop_tracing ();          stop_tracing ();
1738    return FALSE;          return FALSE;
1739  }  }
1740    
1741  void  void
1742  on_tracedialogclosebutton_clicked (GtkButton *button, gpointer user_data)  on_tracedialogclosebutton_clicked (GtkButton * button, gpointer user_data)
1743  {  {
1744    stop_tracing ();          stop_tracing ();
1745    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1746  }  }
1747    
1748  /* TRACE WARNING DIALOG*/  /* TRACE WARNING DIALOG*/
1749  gboolean  gboolean
1750  on_tracewarningdialog_delete_event     (GtkWidget       *widget,  on_tracewarningdialog_delete_event (GtkWidget * widget,
1751                                          GdkEvent        *event,                                      GdkEvent * event, gpointer user_data)
                                         gpointer         user_data)  
1752  {  {
1753    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1754    return FALSE;          return FALSE;
1755  }  }
1756    
1757    
1758  void  void
1759  on_tracewarningokbutton_clicked        (GtkButton       *button,  on_tracewarningokbutton_clicked (GtkButton * button, gpointer user_data)
                                         gpointer         user_data)  
1760  {  {
1761    gtk_widget_set_sensitive (mainwindow, 1);          gtk_widget_set_sensitive (mainwindow, 1);
1762    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1763  }  }
1764    
1765    
1766  /* HELP DIALOG */  /* HELP DIALOG */
1767  void  void
1768  on_helpokbutton_clicked                (GtkButton       *button,  on_helpokbutton_clicked (GtkButton * button, gpointer user_data)
                                         gpointer         user_data)  
1769  {  {
1770    gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));          gtk_widget_destroy (gtk_widget_get_toplevel (GTK_WIDGET (button)));
1771  }  }
1772    
1773    

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.23

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26