← Back to branch summary

~siretart/gnucash/ubuntu-fullsource

« back to all changes in this revision

Viewing changes to src/gnome/dialog-progress.c

  • Committer: Reinhard Tartler
  • Date: 2008-08-03 07:25:46 UTC
  • Revision ID: siretart@tauware.de-20080803072546-y6p8xda8zpfi62ys
import gnucash_2.2.4.orig.tar.gz

The original tarball had the md5sum: 27e660297dc5b8ce574515779d05a5a5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gnome/dialog-progress.c
 
1
/********************************************************************\
 
2
 * dialog-progress.c -- GnuCash progress dialog                     *
 
3
 * Copyright (C) 2000 Dave Peticolas                                *
 
4
 *                                                                  *
 
5
 * This program is free software; you can redistribute it and/or    *
 
6
 * modify it under the terms of the GNU General Public License as   *
 
7
 * published by the Free Software Foundation; either version 2 of   *
 
8
 * the License, or (at your option) any later version.              *
 
9
 *                                                                  *
 
10
 * This program is distributed in the hope that it will be useful,  *
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 
13
 * GNU General Public License for more details.                     *
 
14
 *                                                                  *
 
15
 * You should have received a copy of the GNU General Public License*
 
16
 * along with this program; if not, contact:                        *
 
17
 *                                                                  *
 
18
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 
19
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 
20
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 
21
 *                                                                  *
 
22
\********************************************************************/
 
23
 
 
24
#include "config.h"
 
25
 
 
26
#include <gtk/gtk.h>
 
27
#include <glib/gi18n.h>
 
28
#include <libguile.h>
 
29
#include "guile-mappings.h"
 
30
 
 
31
#include "dialog-progress.h"
 
32
#include "dialog-utils.h"
 
33
 
 
34
 
 
35
struct _GNCProgressDialog
 
36
{
 
37
  GtkWidget *dialog;
 
38
 
 
39
  GtkWidget *heading_label;
 
40
  GtkWidget *progress_bar;
 
41
 
 
42
  GtkWidget *ok_button;
 
43
  GtkWidget *cancel_button;
 
44
 
 
45
  GNCProgressCancelFunc cancel_func;
 
46
  gpointer user_data;
 
47
 
 
48
  SCM cancel_scm_func;
 
49
 
 
50
  gboolean use_ok_button;
 
51
  gboolean closed;
 
52
  gboolean finished;
 
53
  gboolean destroyed;
 
54
  gboolean title_set;
 
55
};
 
56
 
 
57
 
 
58
static void
 
59
gnc_progress_maybe_destroy (GNCProgressDialog *progress)
 
60
{
 
61
  if (!(progress->closed && progress->destroyed))
 
62
    return;
 
63
 
 
64
  gtk_widget_destroy(progress->dialog);
 
65
}
 
66
 
 
67
static void
 
68
ok_cb(GtkWidget * widget, gpointer data)
 
69
{
 
70
  GNCProgressDialog *progress = data; 
 
71
 
 
72
  gtk_widget_hide(progress->dialog);
 
73
  progress->closed = TRUE;
 
74
  gnc_progress_maybe_destroy (progress);
 
75
}
 
76
 
 
77
static void
 
78
cancel_cb(GtkWidget * widget, gpointer data)
 
79
{
 
80
  GNCProgressDialog *progress = data; 
 
81
 
 
82
  if (progress->cancel_func && !progress->cancel_func (progress->user_data))
 
83
    return;
 
84
 
 
85
  if (progress->cancel_scm_func != SCM_UNDEFINED)
 
86
  {
 
87
    SCM result;
 
88
 
 
89
    result = scm_call_0(progress->cancel_scm_func);
 
90
 
 
91
    if (!SCM_NFALSEP (result))
 
92
      return;
 
93
  }
 
94
 
 
95
  gtk_widget_hide(progress->dialog);
 
96
  progress->closed = TRUE;
 
97
  gnc_progress_maybe_destroy (progress);
 
98
}
 
99
 
 
100
static gboolean
 
101
delete_cb(GtkWidget *widget, GdkEvent  *event, gpointer data)
 
102
{
 
103
  GNCProgressDialog *progress = data; 
 
104
 
 
105
  if (progress->finished)
 
106
  {
 
107
    gtk_widget_hide(progress->dialog);
 
108
    progress->closed = TRUE;
 
109
    gnc_progress_maybe_destroy (progress);
 
110
    return TRUE;
 
111
  }
 
112
 
 
113
  if (progress->cancel_func)
 
114
  {
 
115
    if (progress->cancel_func (progress->user_data))
 
116
    {
 
117
      gtk_widget_hide(progress->dialog);
 
118
      progress->closed = TRUE;
 
119
      gnc_progress_maybe_destroy (progress);
 
120
      return TRUE;
 
121
    }
 
122
  }
 
123
 
 
124
  if (progress->cancel_scm_func != SCM_UNDEFINED)
 
125
  {
 
126
    SCM result;
 
127
 
 
128
    result = scm_call_0(progress->cancel_scm_func);
 
129
 
 
130
    if (SCM_NFALSEP (result))
 
131
    {
 
132
      gtk_widget_hide(progress->dialog);
 
133
      progress->closed = TRUE;
 
134
      gnc_progress_maybe_destroy (progress);
 
135
      return TRUE;
 
136
    }
 
137
  }
 
138
 
 
139
  /* Don't delete the window, wait for gnc_progress_dialog_destroy. */
 
140
  return TRUE;
 
141
}
 
142
 
 
143
static void
 
144
destroy_cb(GtkObject *object, gpointer data)
 
145
{
 
146
  GNCProgressDialog *progress = data;
 
147
 
 
148
  /* Make sure the callbacks aren't invoked */
 
149
  progress->cancel_func = NULL;
 
150
  if (progress->cancel_scm_func != SCM_UNDEFINED)
 
151
    scm_gc_unprotect_object (progress->cancel_scm_func);
 
152
  progress->cancel_scm_func = SCM_UNDEFINED;
 
153
 
 
154
  g_free(progress);
 
155
}
 
156
 
 
157
static void
 
158
gnc_progress_dialog_create(GtkWidget * parent, GNCProgressDialog *progress)
 
159
{
 
160
  GtkWidget *dialog;
 
161
  GtkObject *tdo;
 
162
  GladeXML  *xml;
 
163
 
 
164
  xml = gnc_glade_xml_new ("progress.glade", "Progress Dialog");
 
165
 
 
166
  dialog = glade_xml_get_widget (xml, "Progress Dialog");
 
167
  progress->dialog = dialog;
 
168
  tdo = GTK_OBJECT (dialog);
 
169
 
 
170
  /* parent */
 
171
  if (parent != NULL)
 
172
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
 
173
 
 
174
  g_signal_connect (tdo, "delete_event",
 
175
                    G_CALLBACK (delete_cb), progress);
 
176
 
 
177
  g_signal_connect (tdo, "destroy", G_CALLBACK (destroy_cb), progress);
 
178
 
 
179
  progress->heading_label = glade_xml_get_widget (xml, "heading_label");
 
180
  gtk_widget_hide(progress->heading_label);
 
181
 
 
182
  progress->progress_bar = glade_xml_get_widget (xml, "progress_bar");
 
183
 
 
184
  progress->ok_button = glade_xml_get_widget (xml, "ok_button");
 
185
 
 
186
  g_signal_connect(progress->ok_button, "clicked",
 
187
                   G_CALLBACK(ok_cb), progress);
 
188
 
 
189
  if (!progress->use_ok_button)
 
190
    gtk_widget_hide (progress->ok_button);
 
191
 
 
192
  progress->cancel_button = glade_xml_get_widget (xml, "cancel_button");
 
193
 
 
194
  g_signal_connect(progress->cancel_button, "clicked",
 
195
                   G_CALLBACK(cancel_cb), progress);
 
196
 
 
197
  progress->cancel_func = NULL;
 
198
  progress->user_data = NULL;
 
199
 
 
200
  progress->cancel_scm_func = SCM_UNDEFINED;
 
201
 
 
202
  progress->closed = FALSE;
 
203
  progress->finished = FALSE;
 
204
  progress->destroyed = FALSE;
 
205
  progress->title_set = FALSE;
 
206
}
 
207
 
 
208
GNCProgressDialog *
 
209
gnc_progress_dialog_new (GtkWidget * parent, gboolean use_ok_button)
 
210
{
 
211
  GNCProgressDialog *progress;
 
212
 
 
213
  progress = g_new0(GNCProgressDialog, 1);
 
214
 
 
215
  progress->use_ok_button = use_ok_button;
 
216
 
 
217
  gnc_progress_dialog_create(parent, progress);
 
218
 
 
219
  gtk_widget_show(progress->dialog);
 
220
 
 
221
  gnc_progress_dialog_update (progress);
 
222
 
 
223
  return progress;
 
224
}
 
225
 
 
226
void
 
227
gnc_progress_dialog_set_title (GNCProgressDialog *progress, const char *title)
 
228
{
 
229
  if (progress == NULL)
 
230
    return;
 
231
 
 
232
  if (title == NULL)
 
233
    title = "";
 
234
 
 
235
  gtk_window_set_title (GTK_WINDOW (progress->dialog), title);
 
236
 
 
237
  progress->title_set = TRUE;
 
238
 
 
239
  gnc_progress_dialog_update (progress);
 
240
}
 
241
 
 
242
void
 
243
gnc_progress_dialog_set_heading (GNCProgressDialog *progress,
 
244
                                 const char *heading)
 
245
{
 
246
  if (progress == NULL)
 
247
    return;
 
248
 
 
249
  if (heading == NULL || *heading == '\0')
 
250
    gtk_widget_hide (progress->heading_label);
 
251
  else
 
252
  {
 
253
    gtk_label_set_text (GTK_LABEL (progress->heading_label), heading);
 
254
    gtk_widget_show (progress->heading_label);
 
255
  }
 
256
 
 
257
  gnc_progress_dialog_update (progress);
 
258
}
 
259
 
 
260
void
 
261
gnc_progress_dialog_set_cancel_func (GNCProgressDialog *progress,
 
262
                                     GNCProgressCancelFunc cancel_func,
 
263
                                     gpointer user_data)
 
264
{
 
265
  if (progress == NULL)
 
266
    return;
 
267
 
 
268
  progress->cancel_func = cancel_func;
 
269
  progress->user_data = user_data;
 
270
 
 
271
  if (cancel_func)
 
272
    gtk_widget_show (progress->cancel_button);
 
273
}
 
274
 
 
275
void
 
276
gnc_progress_dialog_set_cancel_scm_func (GNCProgressDialog *progress,
 
277
                                         SCM cancel_scm_func)
 
278
{
 
279
  if (progress == NULL)
 
280
    return;
 
281
 
 
282
  if (progress->cancel_scm_func != SCM_UNDEFINED)
 
283
    scm_gc_unprotect_object (progress->cancel_scm_func);
 
284
 
 
285
  if (SCM_PROCEDUREP(cancel_scm_func))
 
286
  {
 
287
    progress->cancel_scm_func = cancel_scm_func;
 
288
    scm_gc_protect_object (cancel_scm_func);
 
289
    gtk_widget_show (progress->cancel_button);
 
290
  }
 
291
  else
 
292
    progress->cancel_scm_func = SCM_UNDEFINED;
 
293
}
 
294
 
 
295
void
 
296
gnc_progress_dialog_set_value (GNCProgressDialog *progress, gdouble value)
 
297
{
 
298
  if (progress == NULL)
 
299
    return;
 
300
 
 
301
  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress->progress_bar), value);
 
302
 
 
303
  gnc_progress_dialog_update (progress);
 
304
}
 
305
 
 
306
void
 
307
gnc_progress_dialog_update (GNCProgressDialog *progress)
 
308
{
 
309
  while (gtk_events_pending())
 
310
    gtk_main_iteration();
 
311
}
 
312
 
 
313
void
 
314
gnc_progress_dialog_finish (GNCProgressDialog *progress)
 
315
{
 
316
  if (progress == NULL)
 
317
    return;
 
318
 
 
319
  if (!progress->use_ok_button)
 
320
  {
 
321
    gtk_widget_hide (progress->dialog);
 
322
    progress->closed = TRUE;
 
323
  }
 
324
 
 
325
  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress->progress_bar), 1.0);
 
326
 
 
327
  gtk_widget_set_sensitive (progress->ok_button, TRUE);
 
328
  gtk_widget_set_sensitive (progress->cancel_button, FALSE);
 
329
 
 
330
  if (GTK_WIDGET_VISIBLE(progress->heading_label))
 
331
    gnc_progress_dialog_set_heading (progress, _("Complete"));
 
332
 
 
333
  if (!progress->title_set)
 
334
    gtk_window_set_title (GTK_WINDOW (progress->dialog), _("Complete"));
 
335
 
 
336
  gtk_window_set_modal (GTK_WINDOW (progress->dialog), FALSE);
 
337
 
 
338
  progress->finished = TRUE;
 
339
 
 
340
  gnc_progress_dialog_update (progress);
 
341
}
 
342
 
 
343
void
 
344
gnc_progress_dialog_destroy (GNCProgressDialog *progress)
 
345
{
 
346
  if (progress == NULL)
 
347
    return;
 
348
 
 
349
  /* Make sure the callbacks aren't invoked */
 
350
  progress->cancel_func = NULL;
 
351
  if (progress->cancel_scm_func != SCM_UNDEFINED)
 
352
    scm_gc_unprotect_object (progress->cancel_scm_func);
 
353
  progress->cancel_scm_func = SCM_UNDEFINED;
 
354
 
 
355
  if (!progress->finished)
 
356
  {
 
357
    gtk_widget_hide (progress->dialog);
 
358
    progress->closed = TRUE;
 
359
  }
 
360
 
 
361
  progress->destroyed = TRUE;
 
362
 
 
363
  gnc_progress_maybe_destroy (progress);
 
364
}