← Back to branch summary

~ubuntu-branches/ubuntu/utopic/cdrdao/utopic

« back to all changes in this revision

Viewing changes to xdao/ProgressDialog.cc

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Suffield
  • Date: 2004-06-24 22:33:16 UTC
  • Revision ID: james.westby@ubuntu.com-20040624223316-534onzugaeeyq61j
Tags: upstream-1.1.9
Import upstream version 1.1.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
xdao/ProgressDialog.cc
 
1
/*  cdrdao - write audio CD-Rs in disc-at-once mode
 
2
 *
 
3
 *  Copyright (C) 1998-2002  Andreas Mueller <andreas@daneb.de>
 
4
 *
 
5
 *  This program is free software; you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation; either version 2 of the License, or
 
8
 *  (at your option) any later version.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
 */
 
19
 
 
20
#include <stdio.h>
 
21
#include <stddef.h>
 
22
#include <ctype.h>
 
23
 
 
24
#include <gtkmm.h>
 
25
#include <gnome.h>
 
26
 
 
27
#include "ProgressDialog.h"
 
28
#include "MessageBox.h"
 
29
#include "TocEdit.h"
 
30
#include "guiUpdate.h"
 
31
#include "CdDevice.h"
 
32
 
 
33
#include "remote.h"
 
34
 
 
35
ProgressDialog::ProgressDialog(ProgressDialogPool *father)
 
36
{
 
37
  Gtk::Label *label;
 
38
  Gtk::HBox *hbox;
 
39
  Gtk::VBox *contents = manage(new Gtk::VBox);
 
40
  Gtk::Table *table;
 
41
  Gtk::Alignment *align;
 
42
 
 
43
  poolFather_ = father;
 
44
  active_ = 0;
 
45
  device_ = NULL;
 
46
  poolNext_ = NULL;
 
47
 
 
48
  contents->set_spacing(5);
 
49
 
 
50
  statusMsg_ = manage(new Gtk::Label());
 
51
  trackProgress_ = manage(new Gtk::ProgressBar);
 
52
  totalProgress_ = manage(new Gtk::ProgressBar);
 
53
  bufferFillRate_ = manage(new Gtk::ProgressBar);
 
54
  writerFillRate_ = manage(new Gtk::ProgressBar);
 
55
  tocName_ = manage(new Gtk::Label);
 
56
 
 
57
  hbox = manage(new Gtk::HBox);
 
58
  label = manage(new Gtk::Label(_("Project: ")));
 
59
  hbox->pack_start(*label, Gtk::PACK_SHRINK);
 
60
  hbox->pack_start(*tocName_, Gtk::PACK_SHRINK);
 
61
  contents->pack_start(*hbox, Gtk::PACK_SHRINK);
 
62
 
 
63
  hbox = manage(new Gtk::HBox);
 
64
  hbox->pack_start(*statusMsg_, Gtk::PACK_SHRINK);
 
65
  contents->pack_start(*hbox, Gtk::PACK_SHRINK);
 
66
 
 
67
  hbox = manage(new Gtk::HBox(true, true));
 
68
  label = manage(new Gtk::Label(_("Elapsed Time: "), 1));
 
69
  hbox->pack_start(*label, Gtk::PACK_SHRINK);
 
70
  currentTime_ = manage(new Gtk::Label());
 
71
  hbox->pack_start(*currentTime_, Gtk::PACK_SHRINK);
 
72
  label = manage(new Gtk::Label(_("Remaining Time: "), 1));
 
73
  hbox->pack_start(*label, Gtk::PACK_SHRINK);
 
74
  remainingTime_ = manage(new Gtk::Label("", 0));
 
75
  hbox->pack_start(*remainingTime_, Gtk::PACK_SHRINK);
 
76
  contents->pack_start(*hbox, Gtk::PACK_SHRINK);
 
77
 
 
78
  table = manage(new Gtk::Table(4, 2, false));
 
79
  table->set_row_spacings(5);
 
80
  table->set_col_spacings(5);
 
81
  contents->pack_start(*table, Gtk::PACK_SHRINK);
 
82
 
 
83
  trackLabel_ = manage(new Gtk::Label(_("Track:")));
 
84
  align = manage(new Gtk::Alignment(1.0, 0.5, 0.0, 0.0));
 
85
  align->add(*trackLabel_);
 
86
  table->attach(*align, 0, 1, 0, 1, Gtk::FILL);
 
87
 
 
88
  hbox = manage(new Gtk::HBox);
 
89
  hbox->pack_start(*trackProgress_);
 
90
  table->attach(*hbox, 1, 2, 0, 1);
 
91
 
 
92
  label = manage(new Gtk::Label(_("Total:")));
 
93
  align = manage(new Gtk::Alignment(1.0, 0.5, 0.0, 0.0));
 
94
  align->add(*label);
 
95
  table->attach(*align, 0, 1, 1, 2, Gtk::FILL);
 
96
 
 
97
  hbox = manage(new Gtk::HBox);
 
98
  hbox->pack_start(*totalProgress_);
 
99
  table->attach(*hbox, 1, 2, 1, 2);
 
100
 
 
101
  bufferFillRateLabel_ = manage(new Gtk::Label(_("Input Buffer:")));
 
102
  align = manage(new Gtk::Alignment(1.0, 0.5, 0.0, 0.0));
 
103
  align->add(*bufferFillRateLabel_);
 
104
  table->attach(*align, 0, 1, 2, 3, Gtk::FILL);
 
105
  
 
106
  hbox = manage(new Gtk::HBox);
 
107
  hbox->pack_start(*bufferFillRate_);
 
108
  table->attach(*hbox, 1, 2, 2, 3);
 
109
  
 
110
  writerFillRateLabel_ = manage(new Gtk::Label(_("Write Buffer:")));
 
111
  table->attach(*writerFillRateLabel_, 0, 1, 3, 4, Gtk::FILL);
 
112
  table->attach(*writerFillRate_, 1, 2, 3, 4);
 
113
  
 
114
  hbox = manage(new Gtk::HBox);
 
115
  hbox->pack_start(*contents, true, true, 10);
 
116
  get_vbox()->pack_start(*hbox, false, false, 10);
 
117
 
 
118
  Gtk::HButtonBox *bbox = manage(new Gtk::HButtonBox(Gtk::BUTTONBOX_SPREAD));
 
119
 
 
120
  cancelButton_ = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));
 
121
  bbox->pack_start(*cancelButton_);
 
122
 
 
123
  closeButton_ = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));
 
124
  bbox->pack_start(*closeButton_);
 
125
 
 
126
  actCloseButtonLabel_ = 2;
 
127
 
 
128
  cancelButton_->signal_clicked().
 
129
    connect(SigC::slot(*this, &ProgressDialog::closeAction));
 
130
  closeButton_->signal_clicked().
 
131
    connect(SigC::slot(*this, &ProgressDialog::closeAction));
 
132
 
 
133
  get_action_area()->pack_start(*bbox);
 
134
  set_size_request(400, -1);
 
135
  show_all_children();
 
136
}
 
137
 
 
138
ProgressDialog::~ProgressDialog()
 
139
{
 
140
}
 
141
 
 
142
void ProgressDialog::start(CdDevice *device, const char *tocFileName)
 
143
{
 
144
  std::string s;
 
145
 
 
146
  if (device == NULL)
 
147
    return;
 
148
 
 
149
  if (active_) {
 
150
    raise();
 
151
    return;
 
152
  }
 
153
 
 
154
  active_ = true;
 
155
  device_ = device;
 
156
 
 
157
  clear();
 
158
 
 
159
  Glib::signal_timeout().connect(slot(*this, &ProgressDialog::time), 1000);
 
160
 
 
161
  statusMsg_->set_text(_("Initializing..."));
 
162
  tocName_->set_text(tocFileName);
 
163
 
 
164
  setCloseButtonLabel(1);
 
165
  cancelButton_->set_sensitive(true);
 
166
 
 
167
  s = device->vendor();
 
168
  s += " ";
 
169
  s += device->product();
 
170
 
 
171
  set_title(s);
 
172
  set_modal(true);
 
173
  show();
 
174
}
 
175
 
 
176
void ProgressDialog::stop()
 
177
{
 
178
  if (active_) {
 
179
    hide();
 
180
    active_ = false;
 
181
    device_ = NULL;
 
182
  }
 
183
}
 
184
 
 
185
bool ProgressDialog::on_delete_event(GdkEventAny*)
 
186
{
 
187
  if (finished_) {
 
188
    poolFather_->stop(this);
 
189
  }
 
190
  return true;
 
191
}
 
192
 
 
193
void ProgressDialog::closeAction()
 
194
{
 
195
  if (finished_) {
 
196
    poolFather_->stop(this);
 
197
    return;
 
198
  }
 
199
 
 
200
  switch (device_->action()) {
 
201
  case CdDevice::A_RECORD:
 
202
    {
 
203
      Ask2Box msg(this, _("Abort Recording"), 0, 2,
 
204
                  _("Abort recording process?"), NULL);
 
205
 
 
206
      if (msg.run() == 1 && device_ != NULL) {
 
207
        cancelButton_->set_sensitive(false);
 
208
        device_->abortDaoRecording();
 
209
      }
 
210
    }
 
211
    break;
 
212
 
 
213
  case CdDevice::A_READ:
 
214
    {        
 
215
      Ask2Box msg(this, _("Abort Reading"), 0, 2, _("Abort reading process?"),
 
216
                  NULL);
 
217
 
 
218
      if (msg.run() == 1 && device_ != NULL) {
 
219
        cancelButton_->set_sensitive(false);
 
220
        device_->abortDaoReading();
 
221
      }
 
222
    }
 
223
    break;
 
224
 
 
225
  case CdDevice::A_DUPLICATE:
 
226
    {        
 
227
      Ask2Box msg(this, _("Abort Process"), 0, 2,
 
228
                  _("Abort duplicating process?"), NULL);
 
229
 
 
230
      if (msg.run() == 1 && device_ != NULL) {
 
231
        cancelButton_->set_sensitive(false);
 
232
        device_->abortDaoDuplication();
 
233
      }
 
234
    }
 
235
    break;
 
236
 
 
237
  case CdDevice::A_BLANK:
 
238
    {        
 
239
      Ask2Box msg(this, _("Abort Process"), 0, 2, _("Abort blanking process?"),
 
240
                  NULL);
 
241
 
 
242
      if (msg.run() == 1 && device_ != NULL) {
 
243
        cancelButton_->set_sensitive(false);
 
244
        device_->abortBlank();
 
245
      }
 
246
    }
 
247
    break;
 
248
  }
 
249
}
 
250
 
 
251
 
 
252
void ProgressDialog::clear()
 
253
{
 
254
  finished_ = 0;
 
255
  actStatus_ = 0;
 
256
  actTrack_ = 0;
 
257
  actTrackProgress_ = 0;
 
258
  actTotalProgress_ = 0;
 
259
  actBufferFill_ = 0;
 
260
  actWriterFill_ = 0;
 
261
 
 
262
  gettimeofday(&time_, NULL);
 
263
  currentTime_->set_text("0:00:00");
 
264
  remainingTime_->set_text("");
 
265
  leadTimeFilled_ = false;
 
266
  statusMsg_->set_text("");
 
267
  trackProgress_->set_fraction(0.0);
 
268
  totalProgress_->set_fraction(0.0);
 
269
  bufferFillRate_->set_fraction(0.0);
 
270
  writerFillRate_->set_fraction(0.0);
 
271
  
 
272
  set_title("");
 
273
}
 
274
 
 
275
void ProgressDialog::update(unsigned long level)
 
276
{
 
277
  int status;
 
278
  int totalTracks;
 
279
  int track;
 
280
  int trackProgress;
 
281
  int totalProgress;
 
282
  int bufferFill;
 
283
  int writerFill;
 
284
  char buf[40];
 
285
  std::string s;
 
286
 
 
287
  if (!active_ || device_ == NULL)
 
288
    return;
 
289
 
 
290
  if (finished_)
 
291
    return;
 
292
 
 
293
  
 
294
  if ((level & UPD_PROGRESS_STATUS) && device_->progressStatusChanged()) {
 
295
    device_->progress(&status, &totalTracks, &track, &trackProgress,
 
296
                      &totalProgress, &bufferFill, &writerFill);
 
297
 
 
298
    if (status != actStatus_ || track != actTrack_) {
 
299
      actStatus_ = status;
 
300
      actTrack_ = track;
 
301
 
 
302
      switch (status) {
 
303
      case PGSMSG_RCD_ANALYZING:
 
304
        actTrack_ = track;
 
305
 
 
306
        s = _("Analyzing track ");
 
307
        sprintf(buf, "%d of %d", track, totalTracks);
 
308
        s += buf;
 
309
 
 
310
        statusMsg_->set_text(s);
 
311
        break;
 
312
 
 
313
      case PGSMSG_RCD_EXTRACTING:
 
314
        actTrack_ = track;
 
315
 
 
316
        s = _("Extracting ");
 
317
        sprintf(buf, "%d", totalTracks);
 
318
        s += buf;
 
319
        s += _(" tracks...");
 
320
 
 
321
        statusMsg_->set_text(s);
 
322
        break;
 
323
 
 
324
      case PGSMSG_WCD_LEADIN:
 
325
        statusMsg_->set_text(_("Writing lead-in..."));
 
326
        break;
 
327
 
 
328
      case PGSMSG_WCD_DATA:
 
329
        actTrack_ = track;
 
330
 
 
331
        s = _("Writing track ");
 
332
        sprintf(buf, "%d of %d", track, totalTracks);
 
333
        s += buf;
 
334
 
 
335
        statusMsg_->set_text(s);
 
336
        break;
 
337
 
 
338
      case PGSMSG_WCD_LEADOUT:
 
339
        statusMsg_->set_text(_("Writing lead-out..."));
 
340
        break;
 
341
 
 
342
      case PGSMSG_BLK:
 
343
        statusMsg_->set_text(_("Blanking..."));
 
344
        break;
 
345
 
 
346
      }
 
347
    }
 
348
 
 
349
    if (trackProgress != actTrackProgress_) {
 
350
      actTrackProgress_ = trackProgress;
 
351
      if (trackProgress <= 1000)
 
352
        trackProgress_->set_fraction(trackProgress / 1000.0);
 
353
    }
 
354
 
 
355
    if (totalProgress != actTotalProgress_) {
 
356
      if (actTotalProgress_ == 0)
 
357
        gettimeofday(&time_, 0);
 
358
      actTotalProgress_ = totalProgress;
 
359
      if (totalProgress <= 1000)
 
360
        totalProgress_->set_fraction(totalProgress / 1000.0);
 
361
    }
 
362
 
 
363
    if (bufferFill != actBufferFill_) {
 
364
      actBufferFill_ = bufferFill;
 
365
      if (bufferFill <= 1000)
 
366
        bufferFillRate_->set_fraction(bufferFill / 100.0);
 
367
    }
 
368
 
 
369
    if (writerFill != actWriterFill_) {
 
370
      actWriterFill_ = writerFill;
 
371
      if (writerFill <= 1000)
 
372
        writerFillRate_->set_fraction(writerFill / 100.0);
 
373
    }
 
374
  }
 
375
  
 
376
  switch (device_->action()) {
 
377
    case CdDevice::A_RECORD:
 
378
      if (device_->status() != CdDevice::DEV_RECORDING) {
 
379
        switch (device_->exitStatus()) {
 
380
        case 0:
 
381
          statusMsg_->set_text(_("Recording finished successfully."));
 
382
          break;
 
383
 
 
384
        case 255:
 
385
          statusMsg_->set_text(_("Cannot execute cdrdao. Please check "
 
386
                                 "your PATH."));
 
387
          break;
 
388
          
 
389
        default:
 
390
          statusMsg_->set_text(_("Recording aborted with error."));
 
391
          break;
 
392
        }
 
393
 
 
394
        finished_ = 1;
 
395
 
 
396
        setCloseButtonLabel(2);
 
397
      }
 
398
      break;
 
399
 
 
400
  case CdDevice::A_READ:
 
401
    if (device_->status() != CdDevice::DEV_READING) {
 
402
      switch (device_->exitStatus()) {
 
403
      case 0:
 
404
        statusMsg_->set_text(_("Reading finished successfully."));
 
405
        break;
 
406
 
 
407
      case 255:
 
408
        statusMsg_->set_text(_("Cannot execute cdrdao. Please check "
 
409
                               "your PATH."));
 
410
        break;
 
411
        
 
412
      default:
 
413
        statusMsg_->set_text(_("Reading aborted."));
 
414
        break;
 
415
      }
 
416
      
 
417
      finished_ = 1;
 
418
      
 
419
      setCloseButtonLabel(2);
 
420
    }
 
421
 
 
422
    break;
 
423
  
 
424
  case CdDevice::A_DUPLICATE:
 
425
    if (device_->status() != CdDevice::DEV_RECORDING) {
 
426
      switch (device_->exitStatus()) {
 
427
      case 0:
 
428
        statusMsg_->set_text(_("CD copying finished successfully."));
 
429
        break;
 
430
 
 
431
      case 255:
 
432
        statusMsg_->set_text(_("Cannot execute cdrdao. Please check "
 
433
                               "your PATH."));
 
434
        break;
 
435
 
 
436
      default:
 
437
        statusMsg_->set_text(_("CD copying aborted with error."));
 
438
        break;
 
439
      }
 
440
 
 
441
      finished_ = 1;
 
442
 
 
443
      setCloseButtonLabel(2);
 
444
    }
 
445
 
 
446
    break;
 
447
 
 
448
  case CdDevice::A_BLANK:
 
449
    if (device_->status() != CdDevice::DEV_BLANKING) {
 
450
      switch (device_->exitStatus()) {
 
451
      case 0:
 
452
        statusMsg_->set_text(_("Blanking finished successfully."));
 
453
        break;
 
454
 
 
455
      case 255:
 
456
        statusMsg_->set_text(_("Cannot execute cdrdao. Please check "
 
457
                               "your PATH."));
 
458
        break;
 
459
        
 
460
      default:
 
461
        statusMsg_->set_text(_("Blanking aborted with error."));
 
462
        break;
 
463
      }
 
464
      
 
465
      finished_ = 1;
 
466
      
 
467
      setCloseButtonLabel(2);
 
468
    }
 
469
 
 
470
    break;
 
471
 
 
472
  default:
 
473
    statusMsg_->set_text(_("Unknow device action!"));
 
474
    break;
 
475
  }
 
476
}
 
477
 
 
478
// Sets label of close button.
 
479
// l: 1: 'abort'        --> CANCEL gnome stock button (i18n)
 
480
//    2: 'dismiss'  --> CLOSE  gnome stock button (i18n)
 
481
void ProgressDialog::setCloseButtonLabel(int l)
 
482
{
 
483
  if (actCloseButtonLabel_ == l)
 
484
    return;
 
485
 
 
486
  switch (l) {
 
487
  case 1:
 
488
    closeButton_->hide();
 
489
    cancelButton_->show();
 
490
    break;
 
491
  case 2:
 
492
    cancelButton_->hide();
 
493
    closeButton_->show();
 
494
    break;
 
495
  }
 
496
 
 
497
  actCloseButtonLabel_ = l;
 
498
}
 
499
 
 
500
bool ProgressDialog::time()
 
501
{
 
502
  char buf[50];
 
503
  struct timeval timenow;
 
504
  long time, time_remain, hours, mins, secs;
 
505
 
 
506
  gettimeofday(&timenow, NULL);
 
507
 
 
508
  time = timenow.tv_sec - time_.tv_sec;
 
509
 
 
510
  hours = time / 3600;
 
511
  mins = (time - (hours * 3600)) / 60;
 
512
  secs = time - ((hours * 3600) + (mins * 60));
 
513
 
 
514
  sprintf(buf, "%ld:%02ld:%02ld", hours, mins, secs);
 
515
  currentTime_->set_text(buf);
 
516
 
 
517
  if (actTotalProgress_ > 10)
 
518
  {
 
519
//Hack!
 
520
// Denis: no shit
 
521
    gfloat aux1, aux2, aux3;
 
522
 
 
523
    if (!leadTimeFilled_)
 
524
    {
 
525
      leadTime_ = time;
 
526
      leadTimeFilled_ = true;
 
527
    }
 
528
 
 
529
    time_remain = (int)
 
530
      (((double)time / ((double)actTotalProgress_ / 1000.0)) + 0.5);
 
531
    time_remain -= time;
 
532
    if (time_remain < 0) time_remain = 0;
 
533
 
 
534
    hours = time_remain / 3600;
 
535
    mins = (time_remain - (hours * 3600)) / 60;
 
536
    secs = time_remain - ((hours * 3600) + (mins * 60));
 
537
 
 
538
    sprintf(buf, "%ld:%02ld:%02ld", hours, mins, secs);
 
539
    remainingTime_->set_text(buf);
 
540
  }
 
541
 
 
542
  if (finished_) 
 
543
    return false;
 
544
  else
 
545
    return true;
 
546
}
 
547
 
 
548
void ProgressDialog::needBufferProgress(bool visible)
 
549
{
 
550
  if (visible) {
 
551
    bufferFillRate_->show();
 
552
    bufferFillRateLabel_->show();
 
553
    writerFillRate_->show();
 
554
    writerFillRateLabel_->show();
 
555
  } else {
 
556
    bufferFillRate_->hide();
 
557
    bufferFillRateLabel_->hide();
 
558
    writerFillRate_->hide();
 
559
    writerFillRateLabel_->hide();
 
560
  }
 
561
}
 
562
 
 
563
void ProgressDialog::needTrackProgress(bool visible)
 
564
{
 
565
  if (visible) {
 
566
    trackProgress_->show();
 
567
    trackLabel_->show();
 
568
  } else {
 
569
    trackProgress_->hide();
 
570
    trackLabel_->hide();
 
571
  }
 
572
}
 
573
 
 
574
 
 
575
ProgressDialogPool::ProgressDialogPool()
 
576
{
 
577
  activeDialogs_ = NULL;
 
578
  pool_ = NULL;
 
579
}
 
580
 
 
581
ProgressDialogPool::~ProgressDialogPool()
 
582
{
 
583
}
 
584
 
 
585
void ProgressDialogPool::update(unsigned long status)
 
586
{
 
587
  ProgressDialog *run;
 
588
 
 
589
  for (run = activeDialogs_; run != NULL; run = run->poolNext_)
 
590
    run->update(status);
 
591
}
 
592
  
 
593
ProgressDialog *ProgressDialogPool::start(CdDevice *device,
 
594
                                          const char *tocFileName,
 
595
                                          bool showBuffer, bool showTrack)
 
596
{
 
597
  ProgressDialog *dialog;
 
598
 
 
599
  if (pool_ == NULL) {
 
600
    dialog = new ProgressDialog(this);
 
601
  }
 
602
  else {
 
603
    dialog = pool_;
 
604
    pool_ = pool_->poolNext_;
 
605
  }
 
606
 
 
607
  dialog->poolNext_ = activeDialogs_;
 
608
  activeDialogs_ = dialog;
 
609
 
 
610
  dialog->needBufferProgress(showBuffer);
 
611
  dialog->needTrackProgress(showTrack);
 
612
 
 
613
  dialog->start(device, tocFileName);
 
614
 
 
615
  return dialog;
 
616
}
 
617
 
 
618
ProgressDialog *ProgressDialogPool::start(Gtk::Window& parent,
 
619
                                          CdDevice *device,
 
620
                                          const char *tocFileName,
 
621
                                          bool showBuffer, bool showTrack)
 
622
{
 
623
  ProgressDialog* dialog = start(device, tocFileName, showBuffer, showTrack);
 
624
  dialog->set_transient_for(parent);
 
625
  return dialog;
 
626
}
 
627
  
 
628
void ProgressDialogPool::stop(ProgressDialog *dialog)
 
629
{
 
630
  ProgressDialog *run, *pred;
 
631
 
 
632
  for (pred = NULL, run = activeDialogs_; run != NULL;
 
633
       pred = run, run = run->poolNext_) {
 
634
    if (run == dialog)
 
635
      break;
 
636
  }
 
637
 
 
638
  if (run == NULL)
 
639
    return;
 
640
 
 
641
  dialog->stop();
 
642
 
 
643
  if (pred == NULL)
 
644
    activeDialogs_ = activeDialogs_->poolNext_;
 
645
  else
 
646
    pred->poolNext_ = run->poolNext_;
 
647
 
 
648
  dialog->poolNext_ = pool_;
 
649
  pool_ = dialog;
 
650
}