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

Diff of /xlog/src/gui_dupecheckdialog.c

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

revision 1.5 by pa4tu, Thu Apr 29 14:59:23 2004 UTC revision 1.6 by pa4tu, Thu Jan 13 20:51:53 2005 UTC
# Line 41  extern GtkWidget *mainwindow; Line 41  extern GtkWidget *mainwindow;
41  extern GList *logwindowlist;  extern GList *logwindowlist;
42    
43  static void  static void
44  on_dupelisttreeview_select_row (GtkTreeSelection * selection, gpointer user_data)  on_dupelisttreeview_select_row (GtkTreeSelection * selection,
45            gpointer user_data)
46  {  {
47          gchar *nr, *lognr, *logn;          gchar *nr, *lognr, *logn;
48          guint i = 0;          guint i = 0;
# Line 59  on_dupelisttreeview_select_row (GtkTreeS Line 60  on_dupelisttreeview_select_row (GtkTreeS
60                  for (i = 0; i < g_list_length (logwindowlist); i++)                  for (i = 0; i < g_list_length (logwindowlist); i++)
61                  {                  {
62                          logwindow = g_list_nth_data (logwindowlist, i);                          logwindow = g_list_nth_data (logwindowlist, i);
63                          logmodel = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                          logmodel = gtk_tree_view_get_model
64                                    (GTK_TREE_VIEW(logwindow->treeview));
65                          valid = gtk_tree_model_get_iter_first (logmodel, &logiter);                          valid = gtk_tree_model_get_iter_first (logmodel, &logiter);
66                          while (valid)                          while (valid)
67                          {                          {
68                                  gtk_tree_model_get (logmodel, &logiter, NR, &lognr, -1);                                  gtk_tree_model_get (logmodel, &logiter, NR, &lognr, -1);
69                                  if ((g_ascii_strcasecmp (nr, lognr) == 0) && (g_ascii_strcasecmp (logn, logwindow->logname) == 0))                                  if ((g_ascii_strcasecmp (nr, lognr) == 0) &&
70                                            (g_ascii_strcasecmp (logn, logwindow->logname) == 0))
71                                  {                                  {
72                                          qsofound = TRUE;                                          qsofound = TRUE;
73                                          break;                                          break;
# Line 76  on_dupelisttreeview_select_row (GtkTreeS Line 79  on_dupelisttreeview_select_row (GtkTreeS
79                  if (qsofound)                  if (qsofound)
80                  {                  {
81                          gtk_notebook_set_current_page (GTK_NOTEBOOK(mainnotebook), i);                          gtk_notebook_set_current_page (GTK_NOTEBOOK(mainnotebook), i);
82                          logselection = gtk_tree_view_get_selection (GTK_TREE_VIEW(logwindow->treeview));                          logselection = gtk_tree_view_get_selection
83                                    (GTK_TREE_VIEW(logwindow->treeview));
84                          gtk_tree_selection_select_iter (logselection,   &logiter);                          gtk_tree_selection_select_iter (logselection,   &logiter);
85                          logpath =       gtk_tree_model_get_path (logmodel, &logiter);                          logpath =       gtk_tree_model_get_path (logmodel, &logiter);
86                          gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(logwindow->treeview), logpath, NULL, TRUE, 0.5, 0.0);                          gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(logwindow->treeview),
87                                    logpath, NULL, TRUE, 0.5, 0.0);
88                          gtk_tree_path_free (logpath);                          gtk_tree_path_free (logpath);
89                  }                  }
90          }          }
# Line 90  on_menu_dupecheck_activate (GtkMenuItem Line 95  on_menu_dupecheck_activate (GtkMenuItem
95  {  {
96          GtkWidget *dupecheckdialog, *dupecheckthisradiobutton,          GtkWidget *dupecheckdialog, *dupecheckthisradiobutton,
97                  *dupecheckallradiobutton, *dupecheckbuttonmode, *dupecheckbuttonband,                  *dupecheckallradiobutton, *dupecheckbuttonmode, *dupecheckbuttonband,
98                  *dupecheckdialog_vbox, *dupecheckmain_vbox, *dupechecklabel,                  *vbox, *dupechecklabel, *dupecheckframe, *dupechecklogs_vbox,
                 *dupecheckframe, *dupechecklogs_vbox, *dupecheckitems_vbox,  
99                  *dupecheckitems_label, *dupecheckinclude_frame, *dupecheckinclude_hbox,                  *dupecheckitems_label, *dupecheckinclude_frame, *dupecheckinclude_hbox,
100                  *dupecheckstatusbar_hbox, *dupecheckstatusbar, *dupecheckprogressbar,                  *dupecheckstatusbar_hbox, *dupecheckstatusbar, *dupecheckprogressbar,
101                  *dupecheckdialog_action_area, *dupecheckcancelbutton, *dupecheckokbutton,                  *dupelistdialog, *dupelistdialogvbox, *dupelistlabel,
102                  *dupelistdialog, *dupelistdialogvbox, *dupelistlabel, *dupelisthseparator,                  *dupelisthseparator, *dupelistscrolledwindow, *dupelisttreeview,
103                  *dupelistscrolledwindow, *dupelisttreeview,                  *duperesultdialog, *duperesultlabel;
104                  *duperesultdialog, *duperesultdialog_vbox, *duperesultlabel,          GdkPixbuf *dupelistdialog_icon_pixbuf;
                 *duperesultdialog_action_area, *duperesultdialogokbutton;  
         GdkPixbuf *dupecheckdialog_icon_pixbuf, *duperesultdialog_icon_pixbuf,  
                 *dupelistdialog_icon_pixbuf;  
105          GList *dupelist = NULL;          GList *dupelist = NULL;
106          GSList *dupecheckthisradiobutton_group = NULL;          GSList *duperadiobutton_group = NULL;
107          logtype *logwindow;          logtype *logwindow;
108          gint i, page, savedpage, pages, row = 0, step, dupecheckresponse, count;          gint i, page, savedpage, pages, row = 0, step, dupecheckresponse, count;
109          gchar *nr, *date, *gmt, *callsign, *band,          gchar *nr, *date, *gmt, *callsign, *band,
# Line 119  on_menu_dupecheck_activate (GtkMenuItem Line 120  on_menu_dupecheck_activate (GtkMenuItem
120          page = gtk_notebook_get_current_page (GTK_NOTEBOOK(mainnotebook));          page = gtk_notebook_get_current_page (GTK_NOTEBOOK(mainnotebook));
121          if (page >= 0)          if (page >= 0)
122          {          {
123                  dupecheckdialog = gtk_dialog_new ();                  dupecheckdialog = gtk_dialog_new_with_buttons (_("xlog - dupecheck"),
124                  gtk_window_set_title (GTK_WINDOW (dupecheckdialog), _("xlog - dupecheck"));                          GTK_WINDOW(mainwindow), GTK_DIALOG_DESTROY_WITH_PARENT,
125                  gtk_window_set_position (GTK_WINDOW (dupecheckdialog), GTK_WIN_POS_MOUSE);                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
126                  dupecheckdialog_icon_pixbuf = create_pixbuf ("xlog.png");                          GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
127                  if (dupecheckdialog_icon_pixbuf)                  vbox = gtk_vbox_new (FALSE, 10);
128                          {                  gtk_container_add (GTK_CONTAINER
129                                  gtk_window_set_icon (GTK_WINDOW (dupecheckdialog), dupecheckdialog_icon_pixbuf);                          (GTK_DIALOG (dupecheckdialog)->vbox), vbox);
                                 g_object_unref (dupecheckdialog_icon_pixbuf);  
                         }  
   
                 dupecheckdialog_vbox = GTK_DIALOG (dupecheckdialog)->vbox;  
                 gtk_widget_show (dupecheckdialog_vbox);  
           
                 dupecheckmain_vbox = gtk_vbox_new (FALSE, 0);  
                 gtk_widget_show (dupecheckmain_vbox);  
                 gtk_box_pack_start (GTK_BOX (dupecheckdialog_vbox), dupecheckmain_vbox, TRUE, TRUE, 0);  
   
130                  dupechecklabel = gtk_label_new (_("Select logs for dupe checking"));                  dupechecklabel = gtk_label_new (_("Select logs for dupe checking"));
131                  gtk_widget_show (dupechecklabel);                  gtk_box_pack_start
132                  gtk_box_pack_start (GTK_BOX (dupecheckmain_vbox), dupechecklabel, FALSE, FALSE, 10);                          (GTK_BOX (vbox), dupechecklabel, FALSE, FALSE, 0);
                 gtk_label_set_justify (GTK_LABEL (dupechecklabel), GTK_JUSTIFY_CENTER);  
                 gtk_label_set_line_wrap (GTK_LABEL (dupechecklabel), TRUE);  
   
133                  dupecheckframe = gtk_frame_new (NULL);                  dupecheckframe = gtk_frame_new (NULL);
134                  gtk_widget_show (dupecheckframe);                  gtk_box_pack_start
135                  gtk_box_pack_start (GTK_BOX (dupecheckmain_vbox), dupecheckframe, FALSE, FALSE, 0);                          (GTK_BOX (vbox), dupecheckframe, FALSE, FALSE, 0);
                 gtk_container_set_border_width (GTK_CONTAINER (dupecheckframe), 10);  
   
136                  dupechecklogs_vbox = gtk_vbox_new (FALSE, 0);                  dupechecklogs_vbox = gtk_vbox_new (FALSE, 0);
                 gtk_widget_show (dupechecklogs_vbox);  
137                  gtk_container_add (GTK_CONTAINER (dupecheckframe), dupechecklogs_vbox);                  gtk_container_add (GTK_CONTAINER (dupecheckframe), dupechecklogs_vbox);
138                    dupecheckthisradiobutton =
139                  dupecheckthisradiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("Check this log"));                          gtk_radio_button_new_with_label (NULL, _("Check this log"));
140                  gtk_widget_show (dupecheckthisradiobutton);                  gtk_box_pack_start (GTK_BOX (dupechecklogs_vbox),
141                  gtk_box_pack_start (GTK_BOX (dupechecklogs_vbox), dupecheckthisradiobutton, TRUE, TRUE, 0);                          dupecheckthisradiobutton, FALSE, FALSE, 0);
142                  gtk_radio_button_set_group (GTK_RADIO_BUTTON (dupecheckthisradiobutton), dupecheckthisradiobutton_group);                  duperadiobutton_group = gtk_radio_button_get_group
143                  dupecheckthisradiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dupecheckthisradiobutton));                          (GTK_RADIO_BUTTON (dupecheckthisradiobutton));
144                    dupecheckallradiobutton = gtk_radio_button_new_with_label
145                  dupecheckallradiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("Check all logs"));                          (duperadiobutton_group, _("Check all logs"));
146                  gtk_widget_show (dupecheckallradiobutton);                  gtk_box_pack_start (GTK_BOX (dupechecklogs_vbox),
147                  gtk_box_pack_start (GTK_BOX (dupechecklogs_vbox), dupecheckallradiobutton, TRUE, TRUE, 0);                          dupecheckallradiobutton, FALSE, FALSE, 0);
                 gtk_radio_button_set_group (GTK_RADIO_BUTTON (dupecheckallradiobutton), dupecheckthisradiobutton_group);  
                 dupecheckthisradiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dupecheckallradiobutton));  
   
                 dupecheckitems_vbox = gtk_vbox_new (FALSE, 0);  
                 gtk_widget_show (dupecheckitems_vbox);  
                 gtk_box_pack_start (GTK_BOX (dupecheckdialog_vbox), dupecheckitems_vbox, TRUE, TRUE, 0);  
   
148                  dupecheckitems_label = gtk_label_new (_("Items to exclude"));                  dupecheckitems_label = gtk_label_new (_("Items to exclude"));
149                  gtk_widget_show (dupecheckitems_label);                  gtk_box_pack_start (GTK_BOX (vbox),     dupecheckitems_label,
150                  gtk_box_pack_start (GTK_BOX (dupecheckitems_vbox), dupecheckitems_label, FALSE, FALSE, 10);                          FALSE, FALSE, 0);
                 gtk_label_set_justify (GTK_LABEL (dupecheckitems_label), GTK_JUSTIFY_CENTER);  
                 gtk_label_set_line_wrap (GTK_LABEL (dupecheckitems_label), TRUE);  
   
151                  dupecheckinclude_frame = gtk_frame_new (NULL);                  dupecheckinclude_frame = gtk_frame_new (NULL);
152                  gtk_widget_show (dupecheckinclude_frame);                  gtk_box_pack_start (GTK_BOX (vbox),     dupecheckinclude_frame,
153                  gtk_box_pack_start (GTK_BOX (dupecheckitems_vbox), dupecheckinclude_frame, FALSE, FALSE, 0);                          FALSE, FALSE, 0);
                 gtk_container_set_border_width (GTK_CONTAINER (dupecheckinclude_frame), 10);  
   
154                  dupecheckinclude_hbox = gtk_hbox_new (TRUE, 0);                  dupecheckinclude_hbox = gtk_hbox_new (TRUE, 0);
155                  gtk_widget_show (dupecheckinclude_hbox);                  gtk_container_add
156                  gtk_container_add (GTK_CONTAINER (dupecheckinclude_frame), dupecheckinclude_hbox);                          (GTK_CONTAINER (dupecheckinclude_frame), dupecheckinclude_hbox);
157                    dupecheckbuttonmode = gtk_check_button_new_with_label (_("Mode"));
158                  dupecheckbuttonmode = gtk_check_button_new_with_mnemonic (_("Mode"));                  gtk_box_pack_start (GTK_BOX (dupecheckinclude_hbox),
159                  gtk_widget_show (dupecheckbuttonmode);                          dupecheckbuttonmode, FALSE, FALSE, 0);
160                  gtk_box_pack_start (GTK_BOX (dupecheckinclude_hbox), dupecheckbuttonmode, TRUE, TRUE, 0);                  dupecheckbuttonband = gtk_check_button_new_with_label (_("Band"));
161                    gtk_box_pack_start (GTK_BOX (dupecheckinclude_hbox),
162                  dupecheckbuttonband = gtk_check_button_new_with_mnemonic (_("Band"));                          dupecheckbuttonband, FALSE, FALSE, 0);
                 gtk_widget_show (dupecheckbuttonband);  
                 gtk_box_pack_start (GTK_BOX (dupecheckinclude_hbox), dupecheckbuttonband, TRUE, TRUE, 0);  
   
163                  dupecheckstatusbar_hbox = gtk_hbox_new (TRUE, 0);                  dupecheckstatusbar_hbox = gtk_hbox_new (TRUE, 0);
164                  gtk_widget_show (dupecheckstatusbar_hbox);                  gtk_box_pack_start (GTK_BOX (vbox),
165                  gtk_box_pack_start (GTK_BOX (dupecheckdialog_vbox), dupecheckstatusbar_hbox, TRUE, FALSE, 10);                          dupecheckstatusbar_hbox, FALSE, FALSE, 0);
   
166                  dupecheckstatusbar = gtk_statusbar_new ();                  dupecheckstatusbar = gtk_statusbar_new ();
167                  gtk_widget_show (dupecheckstatusbar);                  gtk_box_pack_start (GTK_BOX (dupecheckstatusbar_hbox),
168                  gtk_box_pack_start (GTK_BOX (dupecheckstatusbar_hbox), dupecheckstatusbar, TRUE, TRUE, 0);                          dupecheckstatusbar, TRUE, TRUE, 0);
169                  gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (dupecheckstatusbar), FALSE);                  gtk_statusbar_set_has_resize_grip
170                                    (GTK_STATUSBAR (dupecheckstatusbar), FALSE);
171                  dupecheckprogressbar = gtk_progress_bar_new ();                  dupecheckprogressbar = gtk_progress_bar_new ();
172                  gtk_widget_show (dupecheckprogressbar);                  gtk_box_pack_start (GTK_BOX (dupecheckstatusbar_hbox),
173                  gtk_box_pack_start (GTK_BOX (dupecheckstatusbar_hbox), dupecheckprogressbar, FALSE, FALSE, 0);                          dupecheckprogressbar, TRUE, TRUE, 0);
   
                 dupecheckdialog_action_area = GTK_DIALOG (dupecheckdialog)->action_area;  
                 gtk_widget_show (dupecheckdialog_action_area);  
                 gtk_button_box_set_layout (GTK_BUTTON_BOX (dupecheckdialog_action_area), GTK_BUTTONBOX_SPREAD);  
   
                 dupecheckcancelbutton = gtk_button_new_from_stock ("gtk-cancel");  
                 gtk_widget_show (dupecheckcancelbutton);  
                 gtk_dialog_add_action_widget (GTK_DIALOG (dupecheckdialog), dupecheckcancelbutton, GTK_RESPONSE_CANCEL);  
                 GTK_WIDGET_SET_FLAGS (dupecheckcancelbutton, GTK_CAN_DEFAULT);  
   
                 dupecheckokbutton = gtk_button_new_from_stock ("gtk-ok");  
                 gtk_widget_show (dupecheckokbutton);  
                 gtk_dialog_add_action_widget (GTK_DIALOG (dupecheckdialog), dupecheckokbutton, GTK_RESPONSE_OK);  
                 GTK_WIDGET_SET_FLAGS (dupecheckokbutton, GTK_CAN_DEFAULT);  
174    
175                  if (state.dupecheck == 0)                  if (state.dupecheck == 0)
176                  {                  {
177                          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckthisradiobutton), TRUE);                          gtk_toggle_button_set_active
178                          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckallradiobutton), FALSE);                                  (GTK_TOGGLE_BUTTON (dupecheckthisradiobutton), TRUE);
179                            gtk_toggle_button_set_active
180                                    (GTK_TOGGLE_BUTTON (dupecheckallradiobutton), FALSE);
181                  }                  }
182                  else                  else
183                  {                  {
184                          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckthisradiobutton), FALSE);                          gtk_toggle_button_set_active
185                          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckallradiobutton), TRUE);                                  (GTK_TOGGLE_BUTTON (dupecheckthisradiobutton), FALSE);
186                            gtk_toggle_button_set_active
187                                    (GTK_TOGGLE_BUTTON (dupecheckallradiobutton), TRUE);
188                  }                  }
189    
190                  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckbuttonmode), state.notdupecheckmode);                  gtk_toggle_button_set_active
191                  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (dupecheckbuttonband), state.notdupecheckband);                          (GTK_TOGGLE_BUTTON (dupecheckbuttonmode), state.notdupecheckmode);
192                    gtk_toggle_button_set_active
193                            (GTK_TOGGLE_BUTTON (dupecheckbuttonband), state.notdupecheckband);
194    
195                    gtk_widget_show_all (dupecheckdialog);
196                  dupecheckresponse = gtk_dialog_run (GTK_DIALOG(dupecheckdialog));                  dupecheckresponse = gtk_dialog_run (GTK_DIALOG(dupecheckdialog));
197                  if (dupecheckresponse == GTK_RESPONSE_OK)                  if (dupecheckresponse == GTK_RESPONSE_OK)
198                  {                  {
# Line 239  on_menu_dupecheck_activate (GtkMenuItem Line 201  on_menu_dupecheck_activate (GtkMenuItem
201                                  dupe[i] = g_new0 (gchar, 100);                                  dupe[i] = g_new0 (gchar, 100);
202    
203                          gtk_statusbar_pop (GTK_STATUSBAR (dupecheckstatusbar), 1);                          gtk_statusbar_pop (GTK_STATUSBAR (dupecheckstatusbar), 1);
204                          gtk_statusbar_push (GTK_STATUSBAR (dupecheckstatusbar), 1, _("Searching ..."));                          gtk_statusbar_push (GTK_STATUSBAR (dupecheckstatusbar), 1,
205                                    _("Searching..."));
206    
207                          if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (dupecheckthisradiobutton)))                          if (gtk_toggle_button_get_active
208                                    (GTK_TOGGLE_BUTTON (dupecheckthisradiobutton)))
209                                  state.dupecheck = 0;                                  state.dupecheck = 0;
210                          else                          else
211                                  state.dupecheck = 1;                                  state.dupecheck = 1;
212                          state.notdupecheckmode = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(dupecheckbuttonmode));                          state.notdupecheckmode = gtk_toggle_button_get_active
213                          state.notdupecheckband = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(dupecheckbuttonband));                                  (GTK_TOGGLE_BUTTON(dupecheckbuttonmode));
214                            state.notdupecheckband = gtk_toggle_button_get_active
215                                    (GTK_TOGGLE_BUTTON(dupecheckbuttonband));
216    
217                          /* all or this page */                          /* all or this page */
218                          if (state.dupecheck == 0)                          if (state.dupecheck == 0)
219                          {                          {
220                                  page = gtk_notebook_get_current_page (GTK_NOTEBOOK(mainnotebook));                                  page = gtk_notebook_get_current_page
221                                            (GTK_NOTEBOOK(mainnotebook));
222                                  pages = page + 1;                                  pages = page + 1;
223                          }                          }
224                          else                          else
# Line 262  on_menu_dupecheck_activate (GtkMenuItem Line 229  on_menu_dupecheck_activate (GtkMenuItem
229    
230                          savedpage = page;                          savedpage = page;
231                          while (page < pages)                          while (page < pages)
232                          {                       /* make a string consisting of pagecallbandmode and store in a list */                  /* make a string consisting of pagecallbandmode and store in a list */
233                            {
234                                  logwindow = g_list_nth_data (logwindowlist, page);                                  logwindow = g_list_nth_data (logwindowlist, page);
235                                  logmodel = gtk_tree_view_get_model (GTK_TREE_VIEW(logwindow->treeview));                                  logmodel = gtk_tree_view_get_model
236                                            (GTK_TREE_VIEW (logwindow->treeview));
237                                  valid = gtk_tree_model_get_iter_first (logmodel, &iter);                                  valid = gtk_tree_model_get_iter_first (logmodel, &iter);
238                                  while (valid)                                  while (valid)
239                                  {                                  {
# Line 288  on_menu_dupecheck_activate (GtkMenuItem Line 257  on_menu_dupecheck_activate (GtkMenuItem
257                                  page++;                                  page++;
258                          }                          }
259    
260                          /* create the dupelist window, don't make this a dialog because we want                  /* create the dupelist window, don't make this a dialog because we want
261                                  to be able to switch focus to the main window */                                  to be able to switch focus to the main window */
262                          dupelistdialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);                          dupelistdialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
263                          gtk_window_set_title (GTK_WINDOW (dupelistdialog), _("xlog - dupe results"));                          gtk_window_set_title
264                          gtk_window_set_position (GTK_WINDOW (dupelistdialog), GTK_WIN_POS_MOUSE);                                  (GTK_WINDOW (dupelistdialog), _("xlog - dupe results"));
265                          gtk_window_set_default_size (GTK_WINDOW (dupelistdialog), 500, 300);                          gtk_window_set_default_size (GTK_WINDOW (dupelistdialog), 500, 300);
266                          dupelistdialog_icon_pixbuf = create_pixbuf ("xlog.png");                          dupelistdialog_icon_pixbuf = create_pixbuf ("xlog.png");
267                          if (dupelistdialog_icon_pixbuf)                          if (dupelistdialog_icon_pixbuf)
268                                  {                                  {
269                                          gtk_window_set_icon (GTK_WINDOW (dupelistdialog), dupelistdialog_icon_pixbuf);                                          gtk_window_set_icon (GTK_WINDOW (dupelistdialog),
270                                                    dupelistdialog_icon_pixbuf);
271                                          g_object_unref (dupelistdialog_icon_pixbuf);                                          g_object_unref (dupelistdialog_icon_pixbuf);
272                                  }                                  }
   
273                          dupelistdialogvbox = gtk_vbox_new (FALSE, 0);                          dupelistdialogvbox = gtk_vbox_new (FALSE, 0);
274                          gtk_widget_show (dupelistdialogvbox);                          gtk_container_add
275                          gtk_container_add (GTK_CONTAINER (dupelistdialog), dupelistdialogvbox);                                  (GTK_CONTAINER (dupelistdialog), dupelistdialogvbox);
276                    
277                          /* create a treeview */                          /* create a treeview */
278                          dupelistscrolledwindow = gtk_scrolled_window_new (NULL, NULL);                          dupelistscrolledwindow = gtk_scrolled_window_new (NULL, NULL);
279                          gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dupelistscrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);                          gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
280                          gtk_widget_show (dupelistscrolledwindow);                                  (dupelistscrolledwindow),
281                          gtk_box_pack_start (GTK_BOX (dupelistdialogvbox), dupelistscrolledwindow, TRUE, TRUE, 0);                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
282                          gtk_box_reorder_child (GTK_BOX (dupelistdialogvbox), dupelistscrolledwindow, 0);                          gtk_box_pack_start (GTK_BOX (dupelistdialogvbox),
283                                    dupelistscrolledwindow, TRUE, TRUE, 0);
284                            gtk_box_reorder_child (GTK_BOX (dupelistdialogvbox),
285                                    dupelistscrolledwindow, 0);
286                          dupestore = gtk_tree_store_new (7, G_TYPE_STRING, G_TYPE_STRING,                          dupestore = gtk_tree_store_new (7, G_TYPE_STRING, G_TYPE_STRING,
287                                  G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);                                  G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
288                          dupelisttreeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dupestore));                                  G_TYPE_STRING);
289                          gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dupestore), 4, GTK_SORT_ASCENDING);                          dupelisttreeview = gtk_tree_view_new_with_model
290                                    (GTK_TREE_MODEL (dupestore));
291                            gtk_tree_sortable_set_sort_column_id
292                                    (GTK_TREE_SORTABLE (dupestore), 4, GTK_SORT_ASCENDING);
293                          g_object_unref (G_OBJECT (dupestore));                          g_object_unref (G_OBJECT (dupestore));
294                          gtk_widget_show (dupelisttreeview);                          gtk_container_add (GTK_CONTAINER (dupelistscrolledwindow),
295                          gtk_container_add (GTK_CONTAINER (dupelistscrolledwindow), dupelisttreeview);                                  dupelisttreeview);
296    
297                          /* add callback for selecting a row */                          /* add callback for selecting a row */
298                          selection = G_OBJECT (gtk_tree_view_get_selection(GTK_TREE_VIEW (dupelisttreeview)));                          selection = G_OBJECT (gtk_tree_view_get_selection
299                          gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_SINGLE);                                  (GTK_TREE_VIEW (dupelisttreeview)));
300                          g_signal_connect (selection, "changed", G_CALLBACK (on_dupelisttreeview_select_row), NULL);                          gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
301                                    GTK_SELECTION_SINGLE);
302                            g_signal_connect (selection, "changed",
303                                    G_CALLBACK (on_dupelisttreeview_select_row), NULL);
304    
305                          /* add columns */                          /* add columns */
306                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
307                          dupecolumn = gtk_tree_view_column_new_with_attributes ("LOG", duperenderer, "text", 0, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
308                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("LOG", duperenderer, "text", 0, NULL);
309                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
310                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
311                            gtk_tree_view_append_column
312                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
313                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
314                          dupecolumn = gtk_tree_view_column_new_with_attributes ("NR", duperenderer, "text", 1, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
315                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("NR", duperenderer, "text", 1, NULL);
316                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
317                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
318                            gtk_tree_view_append_column
319                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
320                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
321                          dupecolumn = gtk_tree_view_column_new_with_attributes ("DATE", duperenderer, "text", 2, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
322                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("DATE", duperenderer, "text", 2, NULL);
323                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
324                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
325                            gtk_tree_view_append_column
326                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
327                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
328                          dupecolumn = gtk_tree_view_column_new_with_attributes ("GMT", duperenderer, "text", 3, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
329                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),     GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("GMT", duperenderer, "text", 3, NULL);
330                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
331                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
332                            gtk_tree_view_append_column
333                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
334                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
335                          dupecolumn = gtk_tree_view_column_new_with_attributes("CALL", duperenderer, "text", 4, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
336                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("CALL", duperenderer, "text", 4, NULL);
337                            gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
338                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
339                          gtk_tree_view_column_set_sort_column_id (dupecolumn, 4);                          gtk_tree_view_column_set_sort_column_id (dupecolumn, 4);
340                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_append_column
341                                            (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
342                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
343                          dupecolumn = gtk_tree_view_column_new_with_attributes("BAND", duperenderer, "text", 5, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
344                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("BAND", duperenderer, "text", 5, NULL);
345                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
346                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
347                            gtk_tree_view_append_column
348                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
349                          duperenderer = gtk_cell_renderer_text_new ();                          duperenderer = gtk_cell_renderer_text_new ();
350                          dupecolumn = gtk_tree_view_column_new_with_attributes("MODE", duperenderer, "text", 6, NULL);                          dupecolumn = gtk_tree_view_column_new_with_attributes
351                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn), GTK_TREE_VIEW_COLUMN_GROW_ONLY);                                  ("MODE", duperenderer, "text", 6, NULL);
352                          gtk_tree_view_append_column (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);                          gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (dupecolumn),
353                                    GTK_TREE_VIEW_COLUMN_GROW_ONLY);
354                            gtk_tree_view_append_column
355                                    (GTK_TREE_VIEW (dupelisttreeview), dupecolumn);
356    
357                          dupelisthseparator = gtk_hseparator_new ();                          dupelisthseparator = gtk_hseparator_new ();
358                          gtk_widget_show (dupelisthseparator);                          gtk_box_pack_start (GTK_BOX (dupelistdialogvbox),
359                          gtk_box_pack_start (GTK_BOX (dupelistdialogvbox), dupelisthseparator, FALSE, FALSE, 0);                                  dupelisthseparator, FALSE, FALSE, 0);
360                            dupelistlabel = gtk_label_new
361                          dupelistlabel = gtk_label_new (_("Select an entry to highlight the corresponding entry in the main window"));                                  (_("Select an entry to highlight the corresponding entry in the main window"));
362                          gtk_widget_show (dupelistlabel);                          gtk_box_pack_start
363                          gtk_box_pack_start (GTK_BOX (dupelistdialogvbox), dupelistlabel, FALSE, FALSE, 0);                                  (GTK_BOX (dupelistdialogvbox), dupelistlabel, FALSE, FALSE, 0);
                         gtk_label_set_justify (GTK_LABEL (dupelistlabel), GTK_JUSTIFY_CENTER);  
364                          gtk_label_set_line_wrap (GTK_LABEL (dupelistlabel), TRUE);                          gtk_label_set_line_wrap (GTK_LABEL (dupelistlabel), TRUE);
365                          gtk_misc_set_padding (GTK_MISC (dupelistlabel), 0, 5);                          gtk_misc_set_padding (GTK_MISC (dupelistlabel), 0, 5);
366    
# Line 377  on_menu_dupecheck_activate (GtkMenuItem Line 369  on_menu_dupecheck_activate (GtkMenuItem
369                          while (page < pages)                          while (page < pages)
370                          {       /* check the list against the logs */                          {       /* check the list against the logs */
371                                  logwindow = g_list_nth_data (logwindowlist, page);                                  logwindow = g_list_nth_data (logwindowlist, page);
372                                  logmodel = gtk_tree_view_get_model (GTK_TREE_VIEW (logwindow->treeview));                                  logmodel = gtk_tree_view_get_model
373                                            (GTK_TREE_VIEW (logwindow->treeview));
374                                  valid = gtk_tree_model_get_iter_first (logmodel, &iter);                                  valid = gtk_tree_model_get_iter_first (logmodel, &iter);
375                                  while (valid)                                  while (valid)
376                                  {                                  {
377                                          if (row++ % 50 == 0)                                          if (row++ % 50 == 0)
378                                          {                                          {
379                                                  gtk_progress_bar_pulse (GTK_PROGRESS_BAR (dupecheckprogressbar));                                                  gtk_progress_bar_pulse (GTK_PROGRESS_BAR
380                                                            (dupecheckprogressbar));
381                                                  while (gtk_events_pending ()) gtk_main_iteration ();                                                  while (gtk_events_pending ()) gtk_main_iteration ();
382                                          }                                          }
383                                          gtk_tree_model_get (logmodel, &iter, CALL, &callsign, -1);                                          gtk_tree_model_get (logmodel, &iter, CALL, &callsign, -1);
# Line 405  on_menu_dupecheck_activate (GtkMenuItem Line 399  on_menu_dupecheck_activate (GtkMenuItem
399                                          count = 0;                                          count = 0;
400                                          for (step = 0; step < g_list_length(dupelist); step++)                                          for (step = 0; step < g_list_length(dupelist); step++)
401                                          {                                          {
402                                                  if (g_ascii_strcasecmp (dupestr, g_list_nth_data (dupelist, step)) == 0)                                                  if (g_ascii_strcasecmp (dupestr,
403                                                            g_list_nth_data (dupelist, step)) == 0)
404                                                  {       /* dupe found */                                                  {       /* dupe found */
405                                                          count++;                                                          count++;
406                                                          if (count > 1)                                                          if (count > 1)
407                                                          {                                                          {
408                                                                  dupe[0] = g_strdup (logwindow->logname);                                                                  dupe[0] = g_strdup (logwindow->logname);
409                                                                  gtk_tree_model_get (logmodel, &iter, NR, &nr, -1);                                                                  gtk_tree_model_get
410                                                                            (logmodel, &iter, NR, &nr, -1);
411                                                                  dupe[1] = g_strdup (nr);                                                                  dupe[1] = g_strdup (nr);
412                                                                  gtk_tree_model_get (logmodel, &iter, DATE, &date, -1);                                                                  gtk_tree_model_get
413                                                                            (logmodel, &iter, DATE, &date, -1);
414                                                                  dupe[2] = g_strdup (date);                                                                  dupe[2] = g_strdup (date);
415                                                                  gtk_tree_model_get (logmodel, &iter, GMT, &gmt, -1);                                                                  gtk_tree_model_get
416                                                                            (logmodel, &iter, GMT, &gmt, -1);
417                                                                  dupe[3] = g_strdup (gmt);                                                                  dupe[3] = g_strdup (gmt);
418                                                                  gtk_tree_model_get (logmodel, &iter, CALL, &callsign, -1);                                                                  gtk_tree_model_get
419                                                                            (logmodel, &iter, CALL, &callsign, -1);
420                                                                  dupe[4] = g_strdup (callsign);                                                                  dupe[4] = g_strdup (callsign);
421                                                                  gtk_tree_model_get (logmodel, &iter, BAND, &band, -1);                                                                  gtk_tree_model_get
422                                                                            (logmodel, &iter, BAND, &band, -1);
423                                                                  dupe[5] = g_strdup (band);                                                                  dupe[5] = g_strdup (band);
424                                                                  gtk_tree_model_get (logmodel, &iter, MODE, &mode, -1);                                                                  gtk_tree_model_get
425                                                                            (logmodel, &iter, MODE, &mode, -1);
426                                                                  dupe[6] = g_strdup (mode);                                                                  dupe[6] = g_strdup (mode);
427                                                                  gtk_tree_store_prepend(GTK_TREE_STORE(dupemodel), &dupeiter, NULL);                                                                  gtk_tree_store_prepend (GTK_TREE_STORE
428                                                                  gtk_tree_store_set(GTK_TREE_STORE(dupemodel), &dupeiter,                                                                          (dupemodel), &dupeiter, NULL);
429                                                                          0, dupe[0], 1, dupe[1], 2, dupe[2], 3, dupe[3], 4, dupe[4], 5, dupe[5], 6, dupe[6], -1);                                                                  gtk_tree_store_set (GTK_TREE_STORE (dupemodel),
430                                                                            &dupeiter, 0, dupe[0], 1, dupe[1], 2,
431                                                                            dupe[2], 3, dupe[3], 4, dupe[4], 5,
432                                                                            dupe[5], 6, dupe[6], -1);
433                                                                  dupefound = TRUE;                                                                  dupefound = TRUE;
434                                                          }                                                          }
435                                                  }                                                  }
# Line 442  on_menu_dupecheck_activate (GtkMenuItem Line 446  on_menu_dupecheck_activate (GtkMenuItem
446    
447                          gtk_widget_destroy (dupecheckdialog);                          gtk_widget_destroy (dupecheckdialog);
448                          if (dupefound)                          if (dupefound)
449                                  gtk_widget_show (dupelistdialog);                                  gtk_widget_show_all (dupelistdialog);
450                          else                          else
451                          { /* no dupe found, show a message */                          { /* no dupe found, show a message */
452                                  duperesultdialog = gtk_dialog_new ();                                  duperesultdialog = gtk_dialog_new_with_buttons
453                                            (_("xlog - dupe results"),
454                                            GTK_WINDOW(mainwindow), GTK_DIALOG_DESTROY_WITH_PARENT,
455                                            GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
456                                  gtk_widget_set_size_request (duperesultdialog, 350, 150);                                  gtk_widget_set_size_request (duperesultdialog, 350, 150);
                                 gtk_window_set_title (GTK_WINDOW (duperesultdialog), _("xlog - dupe results"));  
                                 gtk_window_set_position (GTK_WINDOW (duperesultdialog), GTK_WIN_POS_MOUSE);  
                                 duperesultdialog_icon_pixbuf = create_pixbuf ("xlog.png");  
                                 if (duperesultdialog_icon_pixbuf)  
                                         {  
                                                 gtk_window_set_icon (GTK_WINDOW (duperesultdialog), duperesultdialog_icon_pixbuf);  
                                                 g_object_unref (duperesultdialog_icon_pixbuf);  
                                         }  
                           
                                 duperesultdialog_vbox = GTK_DIALOG (duperesultdialog)->vbox;  
                                 gtk_widget_show (duperesultdialog_vbox);  
                           
457                                  duperesultlabel = gtk_label_new (_("No dupes found!"));                                  duperesultlabel = gtk_label_new (_("No dupes found!"));
458                                  gtk_widget_show (duperesultlabel);                                  gtk_container_add (GTK_CONTAINER
459                                  gtk_box_pack_end (GTK_BOX (duperesultdialog_vbox), duperesultlabel, TRUE, TRUE, 0);                                          (GTK_DIALOG (duperesultdialog)->vbox), duperesultlabel);
                                 gtk_label_set_justify (GTK_LABEL (duperesultlabel), GTK_JUSTIFY_CENTER);  
                                 gtk_label_set_line_wrap (GTK_LABEL (duperesultlabel), TRUE);  
                                 gtk_misc_set_padding (GTK_MISC (duperesultlabel), 30, 40);  
   
                                 duperesultdialog_action_area = GTK_DIALOG (duperesultdialog)->action_area;  
                                 gtk_widget_show (duperesultdialog_action_area);  
                                 gtk_button_box_set_layout (GTK_BUTTON_BOX (duperesultdialog_action_area), GTK_BUTTONBOX_SPREAD);  
   
                                 duperesultdialogokbutton = gtk_button_new_from_stock ("gtk-ok");  
                                 gtk_widget_show (duperesultdialogokbutton);  
                                 gtk_dialog_add_action_widget (GTK_DIALOG (duperesultdialog), duperesultdialogokbutton, GTK_RESPONSE_OK);  
                                 GTK_WIDGET_SET_FLAGS (duperesultdialogokbutton, GTK_CAN_DEFAULT);  
   
460                                  gtk_widget_destroy (dupelistdialog);                                  gtk_widget_destroy (dupelistdialog);
461                                  gtk_dialog_run (GTK_DIALOG(duperesultdialog));                                  gtk_widget_show_all (duperesultdialog);
462                                    gtk_dialog_run (GTK_DIALOG (duperesultdialog));
463                                  gtk_widget_destroy (duperesultdialog);                                  gtk_widget_destroy (duperesultdialog);
464                          }                          }
465                  } /* GTK_RESPONSE_OK */                  } /* GTK_RESPONSE_OK */

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6

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