Attachment #31936 for bug #51589

Lines 204-211 Link Here

(-)cdrdao-1.1.8/configure.in (-2 / +2 lines)
204		204
205	en_xdao=yes	205	en_xdao=yes
206	en_scsilib=yes	206	en_scsilib=yes
207	PKG_CHECK_MODULES(GTKMM2, gtkmm-2.0 >= 2.2,[],[en_xdao=no])	207	PKG_CHECK_MODULES(GTKMM2, gtkmm-2.4 >= 2.4,[],[en_xdao=no])
208	PKG_CHECK_MODULES(LIBGUIMM2, libgnomeuimm-2.0 >= 2.0,[],[en_xdao=no])	208	PKG_CHECK_MODULES(LIBGUIMM2, libgnomeuimm-2.6 >= 2.6,[],[en_xdao=no])
209		209
210	dnl Determine source for scsi interface class	210	dnl Determine source for scsi interface class
211	if test "$use_scglib" = default; then	211	if test "$use_scglib" = default; then

Lines 55-63 Link Here

(-)cdrdao-1.1.8/xdao/AddFileDialog.cc (-3 / +2 lines)
55	ok->set_label(Gtk::Stock::ADD.id);	55	ok->set_label(Gtk::Stock::ADD.id);
56	ok->set_use_stock(true);	56	ok->set_use_stock(true);
57		57
58	ok->signal_clicked().connect(SigC::slot(*this,&AddFileDialog::applyAction));	58	ok->signal_clicked().connect(sigc::mem_fun(*this, &AddFileDialog::applyAction));
59	cancel->signal_clicked().connect(SigC::slot(*this,	59	cancel->signal_clicked().connect(sigc::mem_fun(*this, &AddFileDialog::closeAction));
60	&AddFileDialog::closeAction));
61	}	60	}
62		61
63	AddFileDialog::~AddFileDialog()	62	AddFileDialog::~AddFileDialog()





  applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));
  bbox->pack_start(*applyButton_);
  applyButton_->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::applyAction));

  button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLEAR));
  bbox->pack_start(*button);
  button->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::clearAction));

  button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));
  bbox->pack_start(*button);
  button->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::closeAction));

  get_action_area()->pack_start(*bbox);
  show_all_children();





    menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
                         _("CD-TEXT..."),
                         mem_fun(*this, &AudioCDProject::cdTextDialog),
                         _("Edit CD-TEXT data")));
    insert_menus(_("Edit/Project Info..."), menus);
  }

  if (playStatus_ == PAUSED)
    {
      playStatus_ = PLAYING;
      Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
      return;
    }



  guiUpdate(level);

  Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
}

void AudioCDProject::playPause()
{
  if (playStatus_ == PAUSED) {
    playStatus_ = PLAYING;
    Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
  } else if (playStatus_ == PLAYING) {
    playStatus_ = PAUSED;
  }


  std::vector<Info> toollist;
  toollist.push_back(Item(Icon(Gtk::Stock::NEW), _("New"),
                          mem_fun(*gcdmaster, &GCDMaster::newChooserWindow),
                          _("New Project")));
  toollist.push_back(Item(Icon(Gtk::Stock::OPEN), _("Open"),
                          bind(mem_fun(*gcdmaster,&GCDMaster::openProject),
                               (ProjectChooser *)0),
                          _("Open a project")));
  toollist.push_back(Item(Icon(Gtk::Stock::CLOSE), _("Close"),
                          bind(mem_fun(*gcdmaster, &GCDMaster::closeProject),
                               this),
                          _("Close current project")));

  toollist.push_back(Item(Icon(Gtk::Stock::SAVE), _("Save"),
                          mem_fun(*this, &Project::saveProject),
                          _("Save current project")));

  toollist.push_back(Item(Icon(Gtk::Stock::CDROM), _("Record"),
                          mem_fun(*this, &Project::recordToc2CD),
                          _("Record to CD")));

  toollist.push_back(Separator());
  toollist.push_back(Item(Icon(Icons::PLAY), _("Play"),
                          mem_fun(*this, &AudioCDProject::on_play_clicked),
                          _("Play")));
  toollist.push_back(Item(Icon(Icons::STOP), _("Stop"),
                          mem_fun(*this, &AudioCDProject::on_stop_clicked),
                          _("Stop")));
  toollist.push_back(Item(Icon(Icons::PAUSE), _("Pause"),
                          mem_fun(*this, &AudioCDProject::on_pause_clicked),
                          _("Pause")));

  toollist.push_back(Separator());

  std::vector<Info> radiotree;
  radiotree.push_back(Item(Icon(Gtk::Stock::JUMP_TO), _("Select"),
                           mem_fun(*this, &AudioCDProject::on_select_clicked),
                           _("Select Mode")));
  radiotree.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Zoom"),
                           mem_fun(*this, &AudioCDProject::on_zoom_clicked),
                           _("Zoom Mode")));
  toollist.push_back(RadioTree(radiotree));
  toollist.push_back(Separator());

  toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_IN), _("In"),
                          mem_fun(*this, &AudioCDProject::on_zoom_in_clicked),
                          _("Zoom In")));
  toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_OUT), _("Out"),
                          mem_fun(*this, &AudioCDProject::on_zoom_out_clicked),
                          _("Zoom Out")));
  toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Fit"),
                          mem_fun(*this, &AudioCDProject::on_zoom_fit_clicked),
                          _("Zoom Fit")));

  Array<Info>& realtb = create_toolbar(toollist);


void AudioCDProject::createToolbar2()
{
#if 0 
  using namespace Gnome::UI::Items;
  using namespace Gtk::Toolbar_Helpers;


             BONOBO_DOCK_TOP, 0, 0, 0);
  toolbar->set_toolbar_style(Gtk::TOOLBAR_BOTH);
  toolbar->set_icon_size(Gtk::ICON_SIZE_SMALL_TOOLBAR);
#endif  
}

void AudioCDProject::on_play_clicked()





  std::list<Gtk::TargetEntry> drop_types;

  drop_types.push_back(Gtk::TargetEntry("text/uri-list", Gtk::TargetFlags(0), TARGET_URI_LIST));

  drag_dest_set(drop_types,
                Gtk::DEST_DEFAULT_MOTION |
                Gtk::DEST_DEFAULT_HIGHLIGHT |
                Gtk::DEST_DEFAULT_DROP);
#if 0
  signal_drag_data_received().connect(mem_fun(*this, &AudioCDView::drag_data_received_cb));
#endif
  sampleDisplay_ = new SampleDisplay;
  sampleDisplay_->setTocEdit(child->tocEdit());


  markerPos_ = new Gtk::Entry;
  markerPos_->set_editable(true);
  markerPos_->set_size_request(entry_width, -1);
  markerPos_->signal_activate().connect(mem_fun(*this, &AudioCDView::markerSet));

  cursorPos_ = new Gtk::Label;
  cursorPos_->set_size_request(entry_width, -1);

  selectionStartPos_->set_editable(true);
  selectionStartPos_->set_size_request(entry_width, -1);
  selectionStartPos_->signal_activate().
      connect(mem_fun(*this, &AudioCDView::selectionSet));

  selectionEndPos_ = new Gtk::Entry;
  selectionEndPos_->set_editable(true);
  selectionEndPos_->set_size_request(entry_width, -1);
  selectionEndPos_->signal_activate().
      connect(mem_fun(*this, &AudioCDView::selectionSet));

  label = new Gtk::Label(_("Cursor: "));
  selectionInfoBox->pack_start(*label, FALSE, FALSE);


  setMode(SELECT);

  sampleDisplay_->markerSet.connect(mem_fun(*this,
                        &AudioCDView::markerSetCallback));
  sampleDisplay_->selectionSet.connect(mem_fun(*this,
                        &AudioCDView::selectionSetCallback));
  sampleDisplay_->selectionCleared.connect(mem_fun(*this,
                        &AudioCDView::selectionClearedCallback));
  sampleDisplay_->cursorMoved.connect(mem_fun(*this,
  			&AudioCDView::cursorMovedCallback));
  sampleDisplay_->trackMarkSelected.connect(mem_fun(*this,
  			&AudioCDView::trackMarkSelectedCallback));
  sampleDisplay_->trackMarkMoved.connect(mem_fun(*this,
  			&AudioCDView::trackMarkMovedCallback));
  sampleDisplay_->viewModified.connect(mem_fun(*this,
		        &AudioCDView::viewModifiedCallback));

  tocEditView_->sampleViewFull();

    
    menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
                         _("Track Info..."),
                         mem_fun(*this, &AudioCDView::trackInfo),
                         _("Edit track data")));
  
    menus.push_back(Separator());
  
    info = Item(Icon(Gtk::StockID(Gtk::Stock::CUT)),
                _("Cut"),
                mem_fun(*this, &AudioCDView::cutTrackData),
                _("Cut out selected samples"));
    info.set_accel(Gtk::AccelKey("<control>x"));
    menus.push_back(info);

    info = Item(Icon(Gtk::StockID(Gtk::Stock::PASTE)),
                _("Paste"),
                mem_fun(*this, &AudioCDView::pasteTrackData),
                _("Paste previously cut samples"));
    info.set_accel(Gtk::AccelKey("<control>v"));
    menus.push_back(info);

    menus.push_back(Separator());

    info = Item(_("Add Track Mark"),
                mem_fun(*this, &AudioCDView::addTrackMark),
                _("Add track marker at current marker position"));
    info.set_accel(Gtk::AccelKey("T"));
    menus.push_back(info);

    info = Item(_("Add Index Mark"),
                mem_fun(*this, &AudioCDView::addIndexMark),
                _("Add index marker at current marker position"));
    info.set_accel(Gtk::AccelKey("I"));
    menus.push_back(info);
    
    info = Item(_("Add Pre-Gap"),
                mem_fun(*this, &AudioCDView::addPregap),
                _("Add pre-gap at current marker position"));
    info.set_accel(Gtk::AccelKey("P"));
    menus.push_back(info);

    info = Item(_("Remove Track Mark"),
                mem_fun(*this, &AudioCDView::removeTrackMark),
                _("Remove selected track/index marker or pre-gap"));
    info.set_accel(Gtk::AccelKey("<control>D"));
    menus.push_back(info);
 
    menus.push_back(Separator());

    info = Item(_("Append Track"),
                mem_fun(*this, &AudioCDView::appendTrack),
                _("Append track with data from audio file"));
    info.set_accel(Gtk::AccelKey("<control>T"));
    menus.push_back(info);

    info = Item(_("Append File"),
                mem_fun(*this, &AudioCDView::appendFile),
                _("Append data from audio file to last track"));
    info.set_accel(Gtk::AccelKey("<control>F"));
    menus.push_back(info);
  
    info = Item(_("Insert File"),
                mem_fun(*this, &AudioCDView::insertFile),
                _("Insert data from audio file at current marker position"));
    info.set_accel(Gtk::AccelKey("<control>I"));
    menus.push_back(info);

    menus.push_back(Separator());

    menus.push_back(Item(_("Append Silence"),
                         mem_fun(*this, &AudioCDView::appendSilence),
                         _("Append silence to last track")));

    menus.push_back(Item(_("Insert Silence"),
                         mem_fun(*this, &AudioCDView::insertSilence),
                         _("Insert silence at current marker position")));

    Array<Info>& arrayInfo = project->insert_menus(_("Edit/CD-TEXT..."),

  guiUpdate();
}

void
AudioCDView::drag_data_received_cb(const Glib::RefPtr<Gdk::DragContext>& context,
                                   Glib::RefPtr<Gdk::DragContext>& context,
                                   gint x, gint y,
                                   const GtkSelectionData *selection_data,
                                   guint info, guint time)
{
  GList *names = NULL;




public:
  AudioCDView(AudioCDChild *child, AudioCDProject *project);
  ~AudioCDView();
  sigc::signal0<void> add_view;

  void update(unsigned long level);


  void selectionSet();

  void drag_data_received_cb(const Glib::RefPtr<Gdk::DragContext>& context,
			     gint x, gint y,
			     const GtkSelectionData *selection_data,
			     guint info, guint time);
};

#endif




  moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
  moreOptionsButton->add(*moreOptionsBox);
  moreOptionsButton->signal_clicked().
    connect(mem_fun(*this, &BlankCDDialog::moreOptions));
  moreOptionsBox = manage(new Gtk::HBox);
  frameBox->pack_start(*moreOptionsBox);
  moreOptionsBox->pack_end(*moreOptionsButton, false, false);

  startBox->pack_start(*startLabel, false, false);

  button->add(*startBox);
  button->signal_clicked().connect(mem_fun(*this, &BlankCDDialog::startAction));

  Gtk::HBox *hbox2 = manage(new Gtk::HBox);
  hbox2->set_spacing(20);


  Gtk::Button* cancel_but =
    manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));
  cancel_but->signal_clicked().connect(mem_fun(*this, &BlankCDDialog::stop));
  hbox2->pack_start(*cancel_but);
  vbox->pack_start(*hbox2, Gtk::PACK_SHRINK);


void BlankCDDialog::moreOptions()
{
  if (!moreOptionsDialog_) {
	  moreOptionsDialog_ = new Gtk::MessageDialog(*this, _("Blank options"), false, 
                                                Gtk::MESSAGE_QUESTION,
						      Gtk::BUTTONS_CLOSE, true);

    Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
    Gtk::Frame *frame = new Gtk::Frame(_(" More Blank Options "));

    speedSpinButton_->set_digits(0);
    speedSpinButton_->set_sensitive(false);
    adjustment->signal_value_changed().
      connect(mem_fun(*this, &BlankCDDialog::speedChanged));
    hbox->pack_start(*speedSpinButton_, false, false, 10);
  
    speedButton_ = new Gtk::CheckButton(_("Use max."), 0);
    speedButton_->set_active(true);
    speedButton_->signal_toggled().
      connect(mem_fun(*this, &BlankCDDialog::speedButtonChanged));
    hbox->pack_start(*speedButton_, true, true);
    vbox->pack_start(*hbox);
    moreOptionsDialog_->show_all_children();




    action_ = A_RECORD;

    if (process_->commFd() >= 0) {
        Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
                                       process_->commFd()),
                                  process_->commFd(),
                                  Glib::IO_IN | Glib::IO_HUP);

    action_ = A_READ;

    if (process_->commFd() >= 0) {
        Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
                                       process_->commFd()),
                                  process_->commFd(),
                                  Glib::IO_IN | Glib::IO_PRI |

    action_ = A_DUPLICATE;

    if (process_->commFd() >= 0) {
        Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
                                       process_->commFd()),
                                  process_->commFd(),
                                  Glib::IO_IN | Glib::IO_HUP);

    action_ = A_BLANK;

    if (process_->commFd() >= 0) {
        Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
                                       process_->commFd()),
                                  process_->commFd(),
                                  Glib::IO_IN | Glib::IO_HUP);

Lines 30-36 Link Here

(-)cdrdao-1.1.8/xdao/CdDevice.h (-1 / +1 lines)
30	class Process;	30	class Process;
31	class ScsiIf;	31	class ScsiIf;
32		32
33	class CdDevice : public SigC::Object	33	class CdDevice : public sigc::trackable
34	{	34	{
35	public:	35	public:
36	enum Status { DEV_READY, DEV_RECORDING, DEV_READING, DEV_WAITING, DEV_BUSY,	36	enum Status { DEV_READY, DEV_RECORDING, DEV_READING, DEV_WAITING, DEV_BUSY,




      new Gtk::CheckButton(_("Enable Perfomer Entries"));
    page_[i].performerButton->set_active(false);
    page_[i].performerButton->signal_toggled().
      connect(bind(mem_fun(*this, &CdTextDialog::activatePerformerAction), i));
    page_[i].tracks = NULL;
    page_[i].table->attach(*(new Gtk::Label(_("Performer"))), 1, 2, 0, 1);
    page_[i].table->attach(*(new Gtk::Label(_("Title"))), 2, 3, 0, 1);

  
  applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));
  bbox->pack_start(*applyButton_);
  applyButton_->signal_clicked().connect(mem_fun(*this, &CdTextDialog::applyAction));
  
  Gtk::Button *fillButton = new Gtk::Button(_(" Fill Performer "));
  bbox->pack_start(*fillButton);
  fillButton->signal_clicked().connect(mem_fun(*this, &CdTextDialog::fillPerformerAction));

  Gtk::Button *cancelButton = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));
  bbox->pack_start(*cancelButton);
  cancelButton->signal_clicked().connect(mem_fun(*this, &CdTextDialog::stop));

  get_action_area()->pack_start(*bbox);






  selectedRow_ = list_.get_selection()->get_selected();
  list_.get_selection()->signal_changed().
      connect(mem_fun(*this, &DeviceConfDialog::selectionChanged));

  Gtk::Menu *dmenu = manage(new Gtk::Menu);
  Gtk::MenuItem *mi;

  for (i = 0; i <= CdDevice::maxDriverId(); i++) {
    mi = manage(new Gtk::MenuItem(CdDevice::driverName(i)));
    mi->signal_activate().connect(bind(mem_fun(*this,
                                            &DeviceConfDialog::setDriverId),
                                       i));
    mi->show();

  for (i = 0; i <= MAX_DEVICE_TYPE_ID; i++) {
    mi = manage(new
                Gtk::MenuItem(CdDevice::deviceType2string(ID2DEVICE_TYPE[i])));
    mi->signal_activate().connect(bind(mem_fun(*this,
                                            &DeviceConfDialog::setDeviceType),
                                       i));
    mi->show();

  button = manage(new Gtk::Button(_("Rescan")));
  bbox->pack_start(*button);
  button->signal_clicked().
    connect(sigc::mem_fun(*this,&DeviceConfDialog::rescanAction));

  button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::DELETE)));
  bbox->pack_start(*button);
  button->signal_clicked().
    connect(sigc::mem_fun(*this,&DeviceConfDialog::deleteDeviceAction));

  listBox->pack_start(*bbox, Gtk::PACK_SHRINK);


      manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::ADD)));
  bbox->pack_start(*addButton);
  addButton->signal_clicked().
      connect(mem_fun(*this, &DeviceConfDialog::addDeviceAction));
  addDeviceBox->pack_start(*bbox);

  addDeviceFrame_.add(*addDeviceBox);

  Gtk::Button* applyButton =
    manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));
  bbox->pack_start(*applyButton);
  applyButton->signal_clicked().connect(mem_fun(*this,
                                             &DeviceConfDialog::applyAction));
  
  Gtk::Button *resetButton = manage(new Gtk::Button(_("Reset")));
  bbox->pack_start(*resetButton);
  resetButton->signal_clicked().connect(mem_fun(*this,
                                             &DeviceConfDialog::resetAction));

  Gtk::Button *cancelButton =
    manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));
  bbox->pack_start(*cancelButton);
  cancelButton->signal_clicked().connect(mem_fun(*this,
                                              &DeviceConfDialog::closeAction));

  contents->pack_start(*bbox, Gtk::PACK_SHRINK);

Lines 66-72 Link Here

(-)cdrdao-1.1.8/xdao/DumpCDProject.cc (-1 / +1 lines)
66	startBox->pack_start(*pixmap, false, false);	66	startBox->pack_start(*pixmap, false, false);
67	startBox->pack_start(*startLabel, false, false);	67	startBox->pack_start(*startLabel, false, false);
68	button->add(*startBox);	68	button->add(*startBox);
69	button->signal_clicked().connect(slot(*this, &DumpCDProject::start));	69	button->signal_clicked().connect(mem_fun(*this, &DumpCDProject::start));
70	bbox->pack_start(*button, Gtk::PACK_EXPAND_PADDING);	70	bbox->pack_start(*button, Gtk::PACK_EXPAND_PADDING);
71	top_vbox->pack_start(*bbox, Gtk::PACK_SHRINK);	71	top_vbox->pack_start(*bbox, Gtk::PACK_SHRINK);
72		72

Lines 84-90 Link Here

(-)cdrdao-1.1.8/xdao/DuplicateCDProject.cc (-1 / +1 lines)
84	startBox->pack_start(*startLabel, false, false);	84	startBox->pack_start(*startLabel, false, false);
85		85
86	button->add(*startBox);	86	button->add(*startBox);
87	button->signal_clicked().connect(slot(*this, &DuplicateCDProject::start));	87	button->signal_clicked().connect(mem_fun(*this, &DuplicateCDProject::start));
88		88
89	hbox->pack_start(*button, true, false);	89	hbox->pack_start(*button, true, false);
90		90

Lines 40-46 Link Here

(-)cdrdao-1.1.8/xdao/gcdmaster.cc (-2 / +2 lines)
40	blankCDDialog_ = 0;	40	blankCDDialog_ = 0;
41		41
42	readFileSelector_.get_cancel_button()->signal_clicked().	42	readFileSelector_.get_cancel_button()->signal_clicked().
43	connect(slot(*this, &GCDMaster::readFileSelectorCancelCB));	43	connect(mem_fun(*this, &GCDMaster::readFileSelectorCancelCB));
44		44
45	Icons::registerStockIcons();	45	Icons::registerStockIcons();
46	}	46	}
Lines 79-85 Link Here
79	void GCDMaster::openProject(ProjectChooser *projectChooser)	79	void GCDMaster::openProject(ProjectChooser *projectChooser)
80	{	80	{
81	readFileSelector_.get_ok_button()->signal_clicked().	81	readFileSelector_.get_ok_button()->signal_clicked().
82	connect(bind(slot(*this, &GCDMaster::readFileSelectorOKCB),	82	connect(bind(mem_fun(*this, &GCDMaster::readFileSelectorOKCB),
83	projectChooser));	83	projectChooser));
84		84
85	readFileSelector_.show();	85	readFileSelector_.show();

Lines 72-78 Link Here

(-)cdrdao-1.1.8/xdao/MessageBox.cc (-1 / +1 lines)
72	for (i = 1; i <= nButtons; i++) {	72	for (i = 1; i <= nButtons; i++) {
73	Gtk::Button* button = manage(createButton(buttons[i - 1]));	73	Gtk::Button* button = manage(createButton(buttons[i - 1]));
74	button->show();	74	button->show();
75	button->signal_clicked().connect(bind(slot(*this,	75	button->signal_clicked().connect(bind(mem_fun(*this,
76	&MessageBoxBase::buttonAction),	76	&MessageBoxBase::buttonAction),
77	i));	77	i));
78	bbox->add(*button);	78	bbox->add(*button);




  actCloseButtonLabel_ = 2;

  cancelButton_->signal_clicked().
    connect(sigc::mem_fun(*this, &ProgressDialog::closeAction));
  closeButton_->signal_clicked().
    connect(sigc::mem_fun(*this, &ProgressDialog::closeAction));

  get_action_area()->pack_start(*bbox);
  set_size_request(400, -1);


  clear();

  Glib::signal_timeout().connect(mem_fun(*this, &ProgressDialog::time), 1000);

  statusMsg_->set_text(_("Initializing..."));
  tocName_->set_text(tocFileName);




    using namespace Gnome::UI::Items;
    using namespace Gnome::UI::MenuItems;
    fileMenuTree.push_back(New(_("New..."), _("Create a new project"),
                               mem_fun(*gcdmaster,
                                    &GCDMaster::newChooserWindow)));

    // File->New menu
    newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
                               _("_Audio CD"),
                               bind(mem_fun(*gcdmaster,
                                         &GCDMaster::newAudioCDProject2),
                                    (ProjectChooser *)NULL),
                               _("New Audio CD")));

    newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
                               _("_Duplicate CD"),
                               bind(mem_fun(*gcdmaster,
                                         &GCDMaster::newDuplicateCDProject),
                                    (ProjectChooser *)NULL),
                               _("Make a copy of a CD")));

    newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
                               _("_Copy CD to disk"),
                               bind(mem_fun(*gcdmaster,
                                         &GCDMaster::newDumpCDProject),
                                    (ProjectChooser *)NULL),
                               _("Dump CD to disk")));

  guint posFileSaveAs;
  {
    using namespace Gnome::UI::MenuItems;
    fileMenuTree.push_back(Open(bind(mem_fun(*gcdmaster,
                                          &GCDMaster::openProject),
                                     (ProjectChooser *)0)));
    fileMenuTree.push_back(Save(mem_fun(*this, &Project::saveProject)));
    posFileSave = fileMenuTree.size() - 1;
    fileMenuTree.push_back(SaveAs(mem_fun(*this, &Project::saveAsProject)));
    posFileSaveAs = fileMenuTree.size() - 1;

    fileMenuTree.push_back(Gnome::UI::Items::Separator());

//    fileMenuTree.push_back(PrintSetup(mem_fun(*this, &Project::nothing_cb)));
//
//    fileMenuTree.push_back(Gnome::UI::Item(Gnome::UI::Icon(GNOME_STOCK_MENU_PRINT),
//								 "Print Cover...",
//								 mem_fun(*this, &Project::nothing_cb),
//								 "Print Cover"));
//
//    fileMenuTree.push_back(Gnome::UI::Items::Separator());

    // Close the current child (project);
    fileMenuTree.push_back(Close(bind(mem_fun(*gcdmaster, &GCDMaster::closeProject), this)));
    fileMenuTree.push_back(Exit(bind(mem_fun(*gcdmaster, &GCDMaster::appClose), this)));
  }

  guint posActionsRecord;

    editMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
                                _("Project Info..."),

                                mem_fun(*this, &Project::projectInfo),
                                _("Edit global project data")));

    // Actions menu
    actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),
                                   _("_Record"),
                                   mem_fun(*this, &Project::recordToc2CD),
                                   _("Record")));
    posActionsRecord = actionsMenuTree.size() - 1;

    actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),
                                   _("Blank CD-RW"),
                                   bind(mem_fun(*gcdmaster,
                                             &GCDMaster::blankCDRW),
                                        this),
                                   _("Erase a CD-RW")));

//    actionsMenuTree.push_back(Gnome::UI::Item("Fixate CD",
//					    mem_fun(*this, &Project::nothing_cb)));
//    actionsMenuTree.push_back(Gnome::UI::Item("Get Info",
//					    mem_fun(*this, &Project::nothing_cb)));

    // Settings menu
    settingsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PREFERENCES)),
                                    _("Configure Devices..."),
                                    mem_fun(*gcdmaster, &GCDMaster::configureDevices)));
  }

//    settingsMenuTree.push_back(Gnome::UI::MenuItems::Preferences
//  				(mem_fun(*this, &Project::nothing_cb)));


  // Help menu
  //helpMenuTree.push_back(Gnome::UI::Help("Quick Start"));

  helpMenuTree.push_back(Gnome::UI::MenuItems::About
  				(mem_fun(*this, &Project::aboutDialog)));

  {
    using namespace Gnome::UI::Menus;

  if (!saveFileSelector_) {
    saveFileSelector_ = new Gtk::FileSelection(_("Save Project"));
    saveFileSelector_->get_ok_button()->signal_clicked().
      connect(mem_fun(*this, &Project::saveFileSelectorOKCB));
    saveFileSelector_->get_cancel_button()->signal_clicked().
      connect(mem_fun(*this, &Project::saveFileSelectorCancelCB));
    saveFileSelector_->set_transient_for(*this);
  }






  // Connect button signals
  openButton.signal_clicked().
    connect(bind(mem_fun(*gcdmaster, &GCDMaster::openProject), this));
  audioCDButton.signal_clicked().
    connect(bind(mem_fun(*gcdmaster, &GCDMaster::newAudioCDProject2), this));
  copyCDButton.signal_clicked().
    connect(bind(mem_fun(*gcdmaster, &GCDMaster::newDuplicateCDProject), this));
  dumpCDButton.signal_clicked().
    connect(bind(mem_fun(*gcdmaster, &GCDMaster::newDumpCDProject), this));

  vbox.show_all();
}




  speedSpinButton_->set_digits(0);
  speedSpinButton_->show();
  speedSpinButton_->set_sensitive(false);
  adjustment->signal_value_changed().connect(sigc::mem_fun(*this, &RecordCDSource::speedChanged));
  hbox->pack_start(*speedSpinButton_, false, false, 10);

  speedButton_ = new Gtk::CheckButton(_("Use max."), 0);
  speedButton_->set_active(true);
  speedButton_->show();
  speedButton_->signal_toggled().connect(sigc::mem_fun(*this, &RecordCDSource::speedButtonChanged));
  hbox->pack_start(*speedButton_, true, true);
  vbox->pack_start(*hbox);


  moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);
  moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
  moreOptionsButton->add(*moreOptionsBox);
  moreOptionsButton->signal_clicked().connect(mem_fun(*this, &RecordCDSource::moreOptions));
  moreOptionsPixmap->show();
  moreOptionsLabel->show();
  moreOptionsBox->show();

    table->set_col_spacings(10);
    table->set_border_width(5);

    moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, _("Source options"),false, 
                                                Gtk::MESSAGE_QUESTION,
                                                Gtk::BUTTONS_CLOSE, true);

    Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
    Gtk::Frame *frame = new Gtk::Frame(_(" More Source Options "));

	
    for (int i = 0; i <= MAX_CORRECTION_ID; i++) {
      mitem = manage(new Gtk::MenuItem(CORRECTION_TABLE[i].name));
      mitem->signal_activate().connect(bind(mem_fun(*this, &RecordCDSource::setCorrection), i));
      menu->append(*mitem);
    }
  

    for (int i = 0; i <= MAX_SUBCHAN_READ_MODE_ID; i++) {
      mitem = manage(new Gtk::MenuItem(SUBCHAN_READ_MODE_TABLE[i].name));
      mitem->signal_activate().
        connect(bind(mem_fun(*this, &RecordCDSource::setSubChanReadMode), i));
      menu->append(*mitem);
    }





  speedSpinButton_->set_digits(0);
  speedSpinButton_->show();
  speedSpinButton_->set_sensitive(false);
  adjustment->signal_value_changed().connect(sigc::mem_fun(*this, &RecordCDTarget::speedChanged));
  hbox->pack_start(*speedSpinButton_, false, false, 10);

  speedButton_ = new Gtk::CheckButton("Use max.", 0);
  speedButton_->set_active(true);
  speedButton_->show();
  speedButton_->signal_toggled().connect(sigc::mem_fun(*this, &RecordCDTarget::speedButtonChanged));
  hbox->pack_start(*speedButton_, true, true);
  vbox->pack_start(*hbox);


  moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);
  moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
  moreOptionsButton->add(*moreOptionsBox);
  moreOptionsButton->signal_clicked().connect(mem_fun(*this, &RecordCDTarget::moreOptions));
  moreOptionsPixmap->show();
  moreOptionsLabel->show();
  moreOptionsBox->show();

{
  if (!moreOptionsDialog_)
  {
	  moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, "Target options",false, 
                                                Gtk::MESSAGE_QUESTION,
						      Gtk::BUTTONS_CLOSE, true);

    Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
    Gtk::Frame *frame = new Gtk::Frame(" More Target Options ");

    bufferRAMLabel_ = new Gtk::Label("= 1.72 Mb buffer.", 0);
    hbox->pack_start(*bufferRAMLabel_, true, true);
    adjustment->signal_value_changed().
        connect(sigc::mem_fun(*this, &RecordCDTarget::updateBufferRAMLabel));
    
    vbox->pack_start(*hbox);
  }




  startBox->pack_start(*startLabel, false, false);

  button->add(*startBox);
  button->signal_clicked().connect(mem_fun(*this, &RecordTocDialog::startAction));
  hbox->pack_start(*button);

  Gtk::Button* cancel_but =
    manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));
  cancel_but->signal_clicked().connect(mem_fun(*this, &Gtk::Widget::hide));
  hbox->pack_start(*cancel_but);

  vbox->pack_start(*hbox, Gtk::PACK_SHRINK);




  "........."};


SampleDisplay::SampleDisplay():
	pixmap_(NULL),
	trackMarkerPixmap_(NULL),
	indexMarkerPixmap_(NULL),
	trackMarkerSelectedPixmap_(NULL),
	indexMarkerSelectedPixmap_(NULL),
	trackExtendPixmap_(NULL),
	indexExtendPixmap_(NULL),
	drawGc_(NULL)
		
{
  adjustment_ = new Gtk::Adjustment(0.0, 0.0, 1.0);
  adjustment_->signal_value_changed().connect(mem_fun(*this,
                                                   &SampleDisplay::scrollTo));

  trackManager_ = NULL;

  //  pixmap_ = NULL;
  // trackMarkerPixmap_ = indexMarkerPixmap_ = NULL;
  // trackMarkerSelectedPixmap_ = indexMarkerSelectedPixmap_ = NULL;
  // trackExtendPixmap_ = indexExtendPixmap_ = NULL;

  //drawGc_ = NULL;
  
  width_ = height_ = chanHeight_ = lcenter_ = rcenter_ = 0;
  timeLineHeight_ = timeLineY_ = 0;
  timeTickWidth_ = 0;

  selectedTrack_ = 0;
  selectedIndex_ = 0;

  signal_expose_event().connect(mem_fun(*this,
                                     &SampleDisplay::handle_expose_event));
  signal_configure_event().
    connect(mem_fun(*this, &SampleDisplay::handle_configure_event));
  signal_motion_notify_event().
    connect(mem_fun(*this, &SampleDisplay::handle_motion_notify_event));
  signal_button_press_event().
    connect(mem_fun(*this, &SampleDisplay::handleButtonPressEvent));
  signal_button_release_event().
    connect(mem_fun(*this,	&SampleDisplay::handleButtonReleaseEvent));
  signal_enter_notify_event().
    connect(mem_fun(*this, &SampleDisplay::handleEnterEvent));
  signal_leave_notify_event().
    connect(mem_fun(*this, &SampleDisplay::handleLeaveEvent));

  set_events (Gdk::EXPOSURE_MASK
	      | Gdk::LEAVE_NOTIFY_MASK





  void updateToc(unsigned long, unsigned long);

  sigc::signal1<void, unsigned long> markerSet;
  sigc::signal1<void, unsigned long> cursorMoved;
  sigc::signal2<void, unsigned long, unsigned long> selectionSet;
  sigc::signal0<void> selectionCleared;
  sigc::signal3<void, const Track *, int, int> trackMarkSelected;
  sigc::signal4<void, const Track *, int, int, unsigned long> trackMarkMoved;
  sigc::signal2<void, unsigned long, unsigned long> viewModified;
  
protected:
  bool handle_configure_event (GdkEventConfigure *);





#include "TrackDataScrap.h"

class SampleManagerImpl : public sigc::trackable {
public:
  SampleManagerImpl(unsigned long);
  ~SampleManagerImpl();

void SampleManagerImpl::setAbortButton(Gtk::Button* button)
{
  abortButton_ = button;
  button->signal_clicked().connect(mem_fun(*this,
                                        &SampleManagerImpl::abortAction));
}


  if (withGui_) {
    if (progressBar_) progressBar_->set_fraction(0.0);
    if (abortButton_) abortButton_->set_sensitive(true);
    Glib::signal_idle().connect(mem_fun(*this, &SampleManagerImpl::readSamples));
    tocEdit_->blockEdit();
  } else {
    while (readSamples());





  mi = manage(new Gtk::MenuItem("CD-DA"));
  mi->signal_activate().
    connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_DA));
  menu->append(*mi);

  mi = manage(new Gtk::MenuItem("CD-ROM"));
  mi->signal_activate().
    connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType),Toc::CD_ROM));
  menu->append(*mi);

  mi = manage(new Gtk::MenuItem("CD-ROM-XA"));
  mi->signal_activate().
    connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType),
                 Toc::CD_ROM_XA));
  menu->append(*mi);

  mi = manage(new Gtk::MenuItem("CD-I"));
  mi->signal_activate().
    connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_I));
  menu->append(*mi);

  tocType_ = manage(new Gtk::OptionMenu);


  applyButton_ = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));
  bbox->pack_start(*applyButton_);
  applyButton_->signal_clicked().connect(sigc::mem_fun(*this,&TocInfoDialog::applyAction));

  button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));
  bbox->pack_start(*button);
  button->signal_clicked().connect(sigc::mem_fun(*this,&TocInfoDialog::closeAction));

  get_action_area()->pack_start(*bbox);
  show_all_children();

    bval.value = i;

    mi = manage(new Gtk::MenuItem(CD_TEXT_LANGUAGE_CODES[i].name));
    mi->signal_activate().connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedCDTextLanguage), bval));
    mi->show();
    menu->append(*mi);
  }

    bval.value = i;

    mi = manage(new Gtk::MenuItem(CD_TEXT_GENRE_CODES[i].name));
    mi->signal_activate().connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedCDTextGenre), bval));
    mi->show();
    menu->append(*mi);
  }

Lines 223-233 Link Here

(-)cdrdao-1.1.8/xdao/TrackInfoDialog.cc (-2 / +2 lines)
223		223
224	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));	224	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));
225	bbox->pack_start(*applyButton_);	225	bbox->pack_start(*applyButton_);
226	applyButton_->signal_clicked().connect(slot(*this, &TrackInfoDialog::applyAction));	226	applyButton_->signal_clicked().connect(mem_fun(*this, &TrackInfoDialog::applyAction));
227		227
228	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));	228	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));
229	bbox->pack_start(*button);	229	bbox->pack_start(*button);
230	button->signal_clicked().connect(slot(*this, &TrackInfoDialog::closeAction));	230	button->signal_clicked().connect(mem_fun(*this, &TrackInfoDialog::closeAction));
231		231
232	get_action_area()->pack_start(*bbox);	232	get_action_area()->pack_start(*bbox);
233		233

Return to bug 51589

Lines 75-81 Link Here

(-)cdrdao-1.1.8/xdao/AudioCDProject.cc (-17 / +19 lines)
75		75
76	menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),	76	menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
77	_("CD-TEXT..."),	77	_("CD-TEXT..."),
78	slot(*this, &AudioCDProject::cdTextDialog),	78	mem_fun(*this, &AudioCDProject::cdTextDialog),
79	_("Edit CD-TEXT data")));	79	_("Edit CD-TEXT data")));
80	insert_menus(_("Edit/Project Info..."), menus);	80	insert_menus(_("Edit/Project Info..."), menus);
81	}	81	}
Lines 192-198 Link Here
192	if (playStatus_ == PAUSED)	192	if (playStatus_ == PAUSED)
193	{	193	{
194	playStatus_ = PLAYING;	194	playStatus_ = PLAYING;
195	Glib::signal_idle().connect(slot(*this, &AudioCDProject::playCallback));	195	Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
196	return;	196	return;
197	}	197	}
198		198
Lines 248-261 Link Here
248		248
249	guiUpdate(level);	249	guiUpdate(level);
250		250
251	Glib::signal_idle().connect(slot(*this, &AudioCDProject::playCallback));	251	Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
252	}	252	}
253		253
254	void AudioCDProject::playPause()	254	void AudioCDProject::playPause()
255	{	255	{
256	if (playStatus_ == PAUSED) {	256	if (playStatus_ == PAUSED) {
257	playStatus_ = PLAYING;	257	playStatus_ = PLAYING;
258	Glib::signal_idle().connect(slot(*this, &AudioCDProject::playCallback));	258	Glib::signal_idle().connect(mem_fun(*this, &AudioCDProject::playCallback));
259	} else if (playStatus_ == PLAYING) {	259	} else if (playStatus_ == PLAYING) {
260	playStatus_ = PAUSED;	260	playStatus_ = PAUSED;
261	}	261	}
Lines 346-401 Link Here
346		346
347	std::vector<Info> toollist;	347	std::vector<Info> toollist;
348	toollist.push_back(Item(Icon(Gtk::Stock::NEW), _("New"),	348	toollist.push_back(Item(Icon(Gtk::Stock::NEW), _("New"),
349	slot(*gcdmaster, &GCDMaster::newChooserWindow),	349	mem_fun(*gcdmaster, &GCDMaster::newChooserWindow),
350	_("New Project")));	350	_("New Project")));
351	toollist.push_back(Item(Icon(Gtk::Stock::OPEN), _("Open"),	351	toollist.push_back(Item(Icon(Gtk::Stock::OPEN), _("Open"),
352	bind(slot(*gcdmaster,&GCDMaster::openProject),	352	bind(mem_fun(*gcdmaster,&GCDMaster::openProject),
353	(ProjectChooser *)0),	353	(ProjectChooser *)0),
354	_("Open a project")));	354	_("Open a project")));
355	toollist.push_back(Item(Icon(Gtk::Stock::CLOSE), _("Close"),	355	toollist.push_back(Item(Icon(Gtk::Stock::CLOSE), _("Close"),
356	bind(slot(*gcdmaster, &GCDMaster::closeProject),	356	bind(mem_fun(*gcdmaster, &GCDMaster::closeProject),
357	this),	357	this),
358	_("Close current project")));	358	_("Close current project")));
359		359
360	toollist.push_back(Item(Icon(Gtk::Stock::SAVE), _("Save"),	360	toollist.push_back(Item(Icon(Gtk::Stock::SAVE), _("Save"),
361	slot(*this, &Project::saveProject),	361	mem_fun(*this, &Project::saveProject),
362	_("Save current project")));	362	_("Save current project")));
363		363
364	toollist.push_back(Item(Icon(Gtk::Stock::CDROM), _("Record"),	364	toollist.push_back(Item(Icon(Gtk::Stock::CDROM), _("Record"),
365	slot(*this, &Project::recordToc2CD),	365	mem_fun(*this, &Project::recordToc2CD),
366	_("Record to CD")));	366	_("Record to CD")));
367		367
368	toollist.push_back(Separator());	368	toollist.push_back(Separator());
369	toollist.push_back(Item(Icon(Icons::PLAY), _("Play"),	369	toollist.push_back(Item(Icon(Icons::PLAY), _("Play"),
370	slot(*this, &AudioCDProject::on_play_clicked),	370	mem_fun(*this, &AudioCDProject::on_play_clicked),
371	_("Play")));	371	_("Play")));
372	toollist.push_back(Item(Icon(Icons::STOP), _("Stop"),	372	toollist.push_back(Item(Icon(Icons::STOP), _("Stop"),
373	slot(*this, &AudioCDProject::on_stop_clicked),	373	mem_fun(*this, &AudioCDProject::on_stop_clicked),
374	_("Stop")));	374	_("Stop")));
375	toollist.push_back(Item(Icon(Icons::PAUSE), _("Pause"),	375	toollist.push_back(Item(Icon(Icons::PAUSE), _("Pause"),
376	slot(*this, &AudioCDProject::on_pause_clicked),	376	mem_fun(*this, &AudioCDProject::on_pause_clicked),
377	_("Pause")));	377	_("Pause")));
378		378
379	toollist.push_back(Separator());	379	toollist.push_back(Separator());
380		380
381	std::vector<Info> radiotree;	381	std::vector<Info> radiotree;
382	radiotree.push_back(Item(Icon(Gtk::Stock::JUMP_TO), _("Select"),	382	radiotree.push_back(Item(Icon(Gtk::Stock::JUMP_TO), _("Select"),
383	slot(*this, &AudioCDProject::on_select_clicked),	383	mem_fun(*this, &AudioCDProject::on_select_clicked),
384	_("Select Mode")));	384	_("Select Mode")));
385	radiotree.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Zoom"),	385	radiotree.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Zoom"),
386	slot(*this, &AudioCDProject::on_zoom_clicked),	386	mem_fun(*this, &AudioCDProject::on_zoom_clicked),
387	_("Zoom Mode")));	387	_("Zoom Mode")));
388	toollist.push_back(RadioTree(radiotree));	388	toollist.push_back(RadioTree(radiotree));
389	toollist.push_back(Separator());	389	toollist.push_back(Separator());
390		390
391	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_IN), _("In"),	391	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_IN), _("In"),
392	slot(*this, &AudioCDProject::on_zoom_in_clicked),	392	mem_fun(*this, &AudioCDProject::on_zoom_in_clicked),
393	_("Zoom In")));	393	_("Zoom In")));
394	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_OUT), _("Out"),	394	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_OUT), _("Out"),
395	slot(*this, &AudioCDProject::on_zoom_out_clicked),	395	mem_fun(*this, &AudioCDProject::on_zoom_out_clicked),
396	_("Zoom Out")));	396	_("Zoom Out")));
397	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Fit"),	397	toollist.push_back(Item(Icon(Gtk::Stock::ZOOM_FIT), _("Fit"),
398	slot(*this, &AudioCDProject::on_zoom_fit_clicked),	398	mem_fun(*this, &AudioCDProject::on_zoom_fit_clicked),
399	_("Zoom Fit")));	399	_("Zoom Fit")));
400		400
401	Array<Info>& realtb = create_toolbar(toollist);	401	Array<Info>& realtb = create_toolbar(toollist);
Lines 414-419 Link Here
414		414
415	void AudioCDProject::createToolbar2()	415	void AudioCDProject::createToolbar2()
416	{	416	{
		417	#if 0
417	using namespace Gnome::UI::Items;	418	using namespace Gnome::UI::Items;
418	using namespace Gtk::Toolbar_Helpers;	419	using namespace Gtk::Toolbar_Helpers;
419		420
Lines 460-465 Link Here
460	BONOBO_DOCK_TOP, 0, 0, 0);	461	BONOBO_DOCK_TOP, 0, 0, 0);
461	toolbar->set_toolbar_style(Gtk::TOOLBAR_BOTH);	462	toolbar->set_toolbar_style(Gtk::TOOLBAR_BOTH);
462	toolbar->set_icon_size(Gtk::ICON_SIZE_SMALL_TOOLBAR);	463	toolbar->set_icon_size(Gtk::ICON_SIZE_SMALL_TOOLBAR);
		464	#endif
463	}	465	}
464		466
465	void AudioCDProject::on_play_clicked()	467	void AudioCDProject::on_play_clicked()

Lines 439-445 Link Here

(-)cdrdao-1.1.8/xdao/CdDevice.cc (-4 / +4 lines)
439	action_ = A_RECORD;	439	action_ = A_RECORD;
440		440
441	if (process_->commFd() >= 0) {	441	if (process_->commFd() >= 0) {
442	Glib::signal_io().connect(bind(slot(*this, &CdDevice::updateProgress),	442	Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
443	process_->commFd()),	443	process_->commFd()),
444	process_->commFd(),	444	process_->commFd(),
445	Glib::IO_IN \| Glib::IO_HUP);	445	Glib::IO_IN \| Glib::IO_HUP);
Lines 572-578 Link Here
572	action_ = A_READ;	572	action_ = A_READ;
573		573
574	if (process_->commFd() >= 0) {	574	if (process_->commFd() >= 0) {
575	Glib::signal_io().connect(bind(slot(*this, &CdDevice::updateProgress),	575	Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
576	process_->commFd()),	576	process_->commFd()),
577	process_->commFd(),	577	process_->commFd(),
578	Glib::IO_IN \| Glib::IO_PRI \|	578	Glib::IO_IN \| Glib::IO_PRI \|
Lines 728-734 Link Here
728	action_ = A_DUPLICATE;	728	action_ = A_DUPLICATE;
729		729
730	if (process_->commFd() >= 0) {	730	if (process_->commFd() >= 0) {
731	Glib::signal_io().connect(bind(slot(*this, &CdDevice::updateProgress),	731	Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
732	process_->commFd()),	732	process_->commFd()),
733	process_->commFd(),	733	process_->commFd(),
734	Glib::IO_IN \| Glib::IO_HUP);	734	Glib::IO_IN \| Glib::IO_HUP);
Lines 834-840 Link Here
834	action_ = A_BLANK;	834	action_ = A_BLANK;
835		835
836	if (process_->commFd() >= 0) {	836	if (process_->commFd() >= 0) {
837	Glib::signal_io().connect(bind(slot(*this, &CdDevice::updateProgress),	837	Glib::signal_io().connect(bind(mem_fun(*this, &CdDevice::updateProgress),
838	process_->commFd()),	838	process_->commFd()),
839	process_->commFd(),	839	process_->commFd(),
840	Glib::IO_IN \| Glib::IO_HUP);	840	Glib::IO_IN \| Glib::IO_HUP);

Lines 126-134 Link Here

(-)cdrdao-1.1.8/xdao/ProgressDialog.cc (-3 / +3 lines)
126	actCloseButtonLabel_ = 2;	126	actCloseButtonLabel_ = 2;
127		127
128	cancelButton_->signal_clicked().	128	cancelButton_->signal_clicked().
129	connect(SigC::slot(*this, &ProgressDialog::closeAction));	129	connect(sigc::mem_fun(*this, &ProgressDialog::closeAction));
130	closeButton_->signal_clicked().	130	closeButton_->signal_clicked().
131	connect(SigC::slot(*this, &ProgressDialog::closeAction));	131	connect(sigc::mem_fun(*this, &ProgressDialog::closeAction));
132		132
133	get_action_area()->pack_start(*bbox);	133	get_action_area()->pack_start(*bbox);
134	set_size_request(400, -1);	134	set_size_request(400, -1);
Lines 156-162 Link Here
156		156
157	clear();	157	clear();
158		158
159	Glib::signal_timeout().connect(slot(*this, &ProgressDialog::time), 1000);	159	Glib::signal_timeout().connect(mem_fun(*this, &ProgressDialog::time), 1000);
160		160
161	statusMsg_->set_text(_("Initializing..."));	161	statusMsg_->set_text(_("Initializing..."));
162	tocName_->set_text(tocFileName);	162	tocName_->set_text(tocFileName);

Lines 95-107 Link Here

(-)cdrdao-1.1.8/xdao/RecordCDSource.cc (-7 / +7 lines)
95	speedSpinButton_->set_digits(0);	95	speedSpinButton_->set_digits(0);
96	speedSpinButton_->show();	96	speedSpinButton_->show();
97	speedSpinButton_->set_sensitive(false);	97	speedSpinButton_->set_sensitive(false);
98	adjustment->signal_value_changed().connect(SigC::slot(*this, &RecordCDSource::speedChanged));	98	adjustment->signal_value_changed().connect(sigc::mem_fun(*this, &RecordCDSource::speedChanged));
99	hbox->pack_start(*speedSpinButton_, false, false, 10);	99	hbox->pack_start(*speedSpinButton_, false, false, 10);
100		100
101	speedButton_ = new Gtk::CheckButton(_("Use max."), 0);	101	speedButton_ = new Gtk::CheckButton(_("Use max."), 0);
102	speedButton_->set_active(true);	102	speedButton_->set_active(true);
103	speedButton_->show();	103	speedButton_->show();
104	speedButton_->signal_toggled().connect(SigC::slot(*this, &RecordCDSource::speedButtonChanged));	104	speedButton_->signal_toggled().connect(sigc::mem_fun(*this, &RecordCDSource::speedButtonChanged));
105	hbox->pack_start(*speedButton_, true, true);	105	hbox->pack_start(*speedButton_, true, true);
106	vbox->pack_start(*hbox);	106	vbox->pack_start(*hbox);
107		107
Lines 115-121 Link Here
115	moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);	115	moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);
116	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);	116	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
117	moreOptionsButton->add(*moreOptionsBox);	117	moreOptionsButton->add(*moreOptionsBox);
118	moreOptionsButton->signal_clicked().connect(slot(*this, &RecordCDSource::moreOptions));	118	moreOptionsButton->signal_clicked().connect(mem_fun(*this, &RecordCDSource::moreOptions));
119	moreOptionsPixmap->show();	119	moreOptionsPixmap->show();
120	moreOptionsLabel->show();	120	moreOptionsLabel->show();
121	moreOptionsBox->show();	121	moreOptionsBox->show();
Lines 180-188 Link Here
180	table->set_col_spacings(10);	180	table->set_col_spacings(10);
181	table->set_border_width(5);	181	table->set_border_width(5);
182		182
183	moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, _("Source options"),	183	moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, _("Source options"),false,
184	Gtk::MESSAGE_QUESTION,	184	Gtk::MESSAGE_QUESTION,
185	Gtk::BUTTONS_CLOSE);	185	Gtk::BUTTONS_CLOSE, true);
186		186
187	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();	187	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
188	Gtk::Frame *frame = new Gtk::Frame(_(" More Source Options "));	188	Gtk::Frame *frame = new Gtk::Frame(_(" More Source Options "));
Lines 209-215 Link Here
209		209
210	for (int i = 0; i <= MAX_CORRECTION_ID; i++) {	210	for (int i = 0; i <= MAX_CORRECTION_ID; i++) {
211	mitem = manage(new Gtk::MenuItem(CORRECTION_TABLE[i].name));	211	mitem = manage(new Gtk::MenuItem(CORRECTION_TABLE[i].name));
212	mitem->signal_activate().connect(bind(slot(*this, &RecordCDSource::setCorrection), i));	212	mitem->signal_activate().connect(bind(mem_fun(*this, &RecordCDSource::setCorrection), i));
213	menu->append(*mitem);	213	menu->append(*mitem);
214	}	214	}
215		215
Lines 231-237 Link Here
231	for (int i = 0; i <= MAX_SUBCHAN_READ_MODE_ID; i++) {	231	for (int i = 0; i <= MAX_SUBCHAN_READ_MODE_ID; i++) {
232	mitem = manage(new Gtk::MenuItem(SUBCHAN_READ_MODE_TABLE[i].name));	232	mitem = manage(new Gtk::MenuItem(SUBCHAN_READ_MODE_TABLE[i].name));
233	mitem->signal_activate().	233	mitem->signal_activate().
234	connect(bind(slot(*this, &RecordCDSource::setSubChanReadMode), i));	234	connect(bind(mem_fun(*this, &RecordCDSource::setSubChanReadMode), i));
235	menu->append(*mitem);	235	menu->append(*mitem);
236	}	236	}
237		237

Lines 114-133 Link Here

(-)cdrdao-1.1.8/xdao/SampleDisplay.cc (-14 / +24 lines)
114	"........."};	114	"........."};
115		115
116		116
117	SampleDisplay::SampleDisplay()	117	SampleDisplay::SampleDisplay():
		118	pixmap_(NULL),
		119	trackMarkerPixmap_(NULL),
		120	indexMarkerPixmap_(NULL),
		121	trackMarkerSelectedPixmap_(NULL),
		122	indexMarkerSelectedPixmap_(NULL),
		123	trackExtendPixmap_(NULL),
		124	indexExtendPixmap_(NULL),
		125	drawGc_(NULL)
		126
118	{	127	{
119	adjustment_ = new Gtk::Adjustment(0.0, 0.0, 1.0);	128	adjustment_ = new Gtk::Adjustment(0.0, 0.0, 1.0);
120	adjustment_->signal_value_changed().connect(slot(*this,	129	adjustment_->signal_value_changed().connect(mem_fun(*this,
121	&SampleDisplay::scrollTo));	130	&SampleDisplay::scrollTo));
122		131
123	trackManager_ = NULL;	132	trackManager_ = NULL;
124		133
125	pixmap_ = NULL;	134	// pixmap_ = NULL;
126	trackMarkerPixmap_ = indexMarkerPixmap_ = NULL;	135	// trackMarkerPixmap_ = indexMarkerPixmap_ = NULL;
127	trackMarkerSelectedPixmap_ = indexMarkerSelectedPixmap_ = NULL;	136	// trackMarkerSelectedPixmap_ = indexMarkerSelectedPixmap_ = NULL;
128	trackExtendPixmap_ = indexExtendPixmap_ = NULL;	137	// trackExtendPixmap_ = indexExtendPixmap_ = NULL;
129		138
130	drawGc_ = NULL;	139	//drawGc_ = NULL;
		140
131	width_ = height_ = chanHeight_ = lcenter_ = rcenter_ = 0;	141	width_ = height_ = chanHeight_ = lcenter_ = rcenter_ = 0;
132	timeLineHeight_ = timeLineY_ = 0;	142	timeLineHeight_ = timeLineY_ = 0;
133	timeTickWidth_ = 0;	143	timeTickWidth_ = 0;
Lines 151-170 Link Here
151	selectedTrack_ = 0;	161	selectedTrack_ = 0;
152	selectedIndex_ = 0;	162	selectedIndex_ = 0;
153		163
154	signal_expose_event().connect(slot(*this,	164	signal_expose_event().connect(mem_fun(*this,
155	&SampleDisplay::handle_expose_event));	165	&SampleDisplay::handle_expose_event));
156	signal_configure_event().	166	signal_configure_event().
157	connect(slot(*this, &SampleDisplay::handle_configure_event));	167	connect(mem_fun(*this, &SampleDisplay::handle_configure_event));
158	signal_motion_notify_event().	168	signal_motion_notify_event().
159	connect(slot(*this, &SampleDisplay::handle_motion_notify_event));	169	connect(mem_fun(*this, &SampleDisplay::handle_motion_notify_event));
160	signal_button_press_event().	170	signal_button_press_event().
161	connect(slot(*this, &SampleDisplay::handleButtonPressEvent));	171	connect(mem_fun(*this, &SampleDisplay::handleButtonPressEvent));
162	signal_button_release_event().	172	signal_button_release_event().
163	connect(slot(*this, &SampleDisplay::handleButtonReleaseEvent));	173	connect(mem_fun(*this, &SampleDisplay::handleButtonReleaseEvent));
164	signal_enter_notify_event().	174	signal_enter_notify_event().
165	connect(slot(*this, &SampleDisplay::handleEnterEvent));	175	connect(mem_fun(*this, &SampleDisplay::handleEnterEvent));
166	signal_leave_notify_event().	176	signal_leave_notify_event().
167	connect(slot(*this, &SampleDisplay::handleLeaveEvent));	177	connect(mem_fun(*this, &SampleDisplay::handleLeaveEvent));
168		178
169	set_events (Gdk::EXPOSURE_MASK	179	set_events (Gdk::EXPOSURE_MASK
170	\| Gdk::LEAVE_NOTIFY_MASK	180	\| Gdk::LEAVE_NOTIFY_MASK

Lines 80-94 Link Here

(-)cdrdao-1.1.8/xdao/AddSilenceDialog.cc (-3 / +3 lines)
80		80
81	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));	81	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));
82	bbox->pack_start(*applyButton_);	82	bbox->pack_start(*applyButton_);
83	applyButton_->signal_clicked().connect(slot(*this, &AddSilenceDialog::applyAction));	83	applyButton_->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::applyAction));
84		84
85	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLEAR));	85	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLEAR));
86	bbox->pack_start(*button);	86	bbox->pack_start(*button);
87	button->signal_clicked().connect(slot(*this, &AddSilenceDialog::clearAction));	87	button->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::clearAction));
88		88
89	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));	89	button = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));
90	bbox->pack_start(*button);	90	bbox->pack_start(*button);
91	button->signal_clicked().connect(slot(*this, &AddSilenceDialog::closeAction));	91	button->signal_clicked().connect(mem_fun(*this, &AddSilenceDialog::closeAction));
92		92
93	get_action_area()->pack_start(*bbox);	93	get_action_area()->pack_start(*bbox);
94	show_all_children();	94	show_all_children();

Lines 53-67 Link Here

(-)cdrdao-1.1.8/xdao/AudioCDView.cc (-39 / +38 lines)
53		53
54	std::list<Gtk::TargetEntry> drop_types;	54	std::list<Gtk::TargetEntry> drop_types;
55		55
56	drop_types.push_back(Gtk::TargetEntry("text/uri-list", 0, TARGET_URI_LIST));	56	drop_types.push_back(Gtk::TargetEntry("text/uri-list", Gtk::TargetFlags(0), TARGET_URI_LIST));
57		57
58	drag_dest_set(drop_types,	58	drag_dest_set(drop_types,
59	Gtk::DEST_DEFAULT_MOTION \|	59	Gtk::DEST_DEFAULT_MOTION \|
60	Gtk::DEST_DEFAULT_HIGHLIGHT \|	60	Gtk::DEST_DEFAULT_HIGHLIGHT \|
61	Gtk::DEST_DEFAULT_DROP);	61	Gtk::DEST_DEFAULT_DROP);
62		62	#if 0
63	signal_drag_data_received().connect(slot(*this, &AudioCDView::drag_data_received_cb));	63	signal_drag_data_received().connect(mem_fun(*this, &AudioCDView::drag_data_received_cb));
64		64	#endif
65	sampleDisplay_ = new SampleDisplay;	65	sampleDisplay_ = new SampleDisplay;
66	sampleDisplay_->setTocEdit(child->tocEdit());	66	sampleDisplay_->setTocEdit(child->tocEdit());
67		67
Lines 85-91 Link Here
85	markerPos_ = new Gtk::Entry;	85	markerPos_ = new Gtk::Entry;
86	markerPos_->set_editable(true);	86	markerPos_->set_editable(true);
87	markerPos_->set_size_request(entry_width, -1);	87	markerPos_->set_size_request(entry_width, -1);
88	markerPos_->signal_activate().connect(slot(*this, &AudioCDView::markerSet));	88	markerPos_->signal_activate().connect(mem_fun(*this, &AudioCDView::markerSet));
89		89
90	cursorPos_ = new Gtk::Label;	90	cursorPos_ = new Gtk::Label;
91	cursorPos_->set_size_request(entry_width, -1);	91	cursorPos_->set_size_request(entry_width, -1);
Lines 94-106 Link Here
94	selectionStartPos_->set_editable(true);	94	selectionStartPos_->set_editable(true);
95	selectionStartPos_->set_size_request(entry_width, -1);	95	selectionStartPos_->set_size_request(entry_width, -1);
96	selectionStartPos_->signal_activate().	96	selectionStartPos_->signal_activate().
97	connect(slot(*this, &AudioCDView::selectionSet));	97	connect(mem_fun(*this, &AudioCDView::selectionSet));
98		98
99	selectionEndPos_ = new Gtk::Entry;	99	selectionEndPos_ = new Gtk::Entry;
100	selectionEndPos_->set_editable(true);	100	selectionEndPos_->set_editable(true);
101	selectionEndPos_->set_size_request(entry_width, -1);	101	selectionEndPos_->set_size_request(entry_width, -1);
102	selectionEndPos_->signal_activate().	102	selectionEndPos_->signal_activate().
103	connect(slot(*this, &AudioCDView::selectionSet));	103	connect(mem_fun(*this, &AudioCDView::selectionSet));
104		104
105	label = new Gtk::Label(_("Cursor: "));	105	label = new Gtk::Label(_("Cursor: "));
106	selectionInfoBox->pack_start(*label, FALSE, FALSE);	106	selectionInfoBox->pack_start(*label, FALSE, FALSE);
Lines 136-154 Link Here
136		136
137	setMode(SELECT);	137	setMode(SELECT);
138		138
139	sampleDisplay_->markerSet.connect(slot(*this,	139	sampleDisplay_->markerSet.connect(mem_fun(*this,
140	&AudioCDView::markerSetCallback));	140	&AudioCDView::markerSetCallback));
141	sampleDisplay_->selectionSet.connect(slot(*this,	141	sampleDisplay_->selectionSet.connect(mem_fun(*this,
142	&AudioCDView::selectionSetCallback));	142	&AudioCDView::selectionSetCallback));
143	sampleDisplay_->selectionCleared.connect(slot(*this,	143	sampleDisplay_->selectionCleared.connect(mem_fun(*this,
144	&AudioCDView::selectionClearedCallback));	144	&AudioCDView::selectionClearedCallback));
145	sampleDisplay_->cursorMoved.connect(slot(*this,	145	sampleDisplay_->cursorMoved.connect(mem_fun(*this,
146	&AudioCDView::cursorMovedCallback));	146	&AudioCDView::cursorMovedCallback));
147	sampleDisplay_->trackMarkSelected.connect(slot(*this,	147	sampleDisplay_->trackMarkSelected.connect(mem_fun(*this,
148	&AudioCDView::trackMarkSelectedCallback));	148	&AudioCDView::trackMarkSelectedCallback));
149	sampleDisplay_->trackMarkMoved.connect(slot(*this,	149	sampleDisplay_->trackMarkMoved.connect(mem_fun(*this,
150	&AudioCDView::trackMarkMovedCallback));	150	&AudioCDView::trackMarkMovedCallback));
151	sampleDisplay_->viewModified.connect(slot(*this,	151	sampleDisplay_->viewModified.connect(mem_fun(*this,
152	&AudioCDView::viewModifiedCallback));	152	&AudioCDView::viewModifiedCallback));
153		153
154	tocEditView_->sampleViewFull();	154	tocEditView_->sampleViewFull();
Lines 162-240 Link Here
162		162
163	menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),	163	menus.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
164	_("Track Info..."),	164	_("Track Info..."),
165	slot(*this, &AudioCDView::trackInfo),	165	mem_fun(*this, &AudioCDView::trackInfo),
166	_("Edit track data")));	166	_("Edit track data")));
167		167
168	menus.push_back(Separator());	168	menus.push_back(Separator());
169		169
170	info = Item(Icon(Gtk::StockID(Gtk::Stock::CUT)),	170	info = Item(Icon(Gtk::StockID(Gtk::Stock::CUT)),
171	_("Cut"),	171	_("Cut"),
172	slot(*this, &AudioCDView::cutTrackData),	172	mem_fun(*this, &AudioCDView::cutTrackData),
173	_("Cut out selected samples"));	173	_("Cut out selected samples"));
174	info.set_accel(Gtk::Menu::AccelKey("<control>x"));	174	info.set_accel(Gtk::AccelKey("<control>x"));
175	menus.push_back(info);	175	menus.push_back(info);
176		176
177	info = Item(Icon(Gtk::StockID(Gtk::Stock::PASTE)),	177	info = Item(Icon(Gtk::StockID(Gtk::Stock::PASTE)),
178	_("Paste"),	178	_("Paste"),
179	slot(*this, &AudioCDView::pasteTrackData),	179	mem_fun(*this, &AudioCDView::pasteTrackData),
180	_("Paste previously cut samples"));	180	_("Paste previously cut samples"));
181	info.set_accel(Gtk::Menu::AccelKey("<control>v"));	181	info.set_accel(Gtk::AccelKey("<control>v"));
182	menus.push_back(info);	182	menus.push_back(info);
183		183
184	menus.push_back(Separator());	184	menus.push_back(Separator());
185		185
186	info = Item(_("Add Track Mark"),	186	info = Item(_("Add Track Mark"),
187	slot(*this, &AudioCDView::addTrackMark),	187	mem_fun(*this, &AudioCDView::addTrackMark),
188	_("Add track marker at current marker position"));	188	_("Add track marker at current marker position"));
189	info.set_accel(Gtk::Menu::AccelKey("T"));	189	info.set_accel(Gtk::AccelKey("T"));
190	menus.push_back(info);	190	menus.push_back(info);
191		191
192	info = Item(_("Add Index Mark"),	192	info = Item(_("Add Index Mark"),
193	slot(*this, &AudioCDView::addIndexMark),	193	mem_fun(*this, &AudioCDView::addIndexMark),
194	_("Add index marker at current marker position"));	194	_("Add index marker at current marker position"));
195	info.set_accel(Gtk::Menu::AccelKey("I"));	195	info.set_accel(Gtk::AccelKey("I"));
196	menus.push_back(info);	196	menus.push_back(info);
197		197
198	info = Item(_("Add Pre-Gap"),	198	info = Item(_("Add Pre-Gap"),
199	slot(*this, &AudioCDView::addPregap),	199	mem_fun(*this, &AudioCDView::addPregap),
200	_("Add pre-gap at current marker position"));	200	_("Add pre-gap at current marker position"));
201	info.set_accel(Gtk::Menu::AccelKey("P"));	201	info.set_accel(Gtk::AccelKey("P"));
202	menus.push_back(info);	202	menus.push_back(info);
203		203
204	info = Item(_("Remove Track Mark"),	204	info = Item(_("Remove Track Mark"),
205	slot(*this, &AudioCDView::removeTrackMark),	205	mem_fun(*this, &AudioCDView::removeTrackMark),
206	_("Remove selected track/index marker or pre-gap"));	206	_("Remove selected track/index marker or pre-gap"));
207	info.set_accel(Gtk::Menu::AccelKey("<control>D"));	207	info.set_accel(Gtk::AccelKey("<control>D"));
208	menus.push_back(info);	208	menus.push_back(info);
209		209
210	menus.push_back(Separator());	210	menus.push_back(Separator());
211		211
212	info = Item(_("Append Track"),	212	info = Item(_("Append Track"),
213	slot(*this, &AudioCDView::appendTrack),	213	mem_fun(*this, &AudioCDView::appendTrack),
214	_("Append track with data from audio file"));	214	_("Append track with data from audio file"));
215	info.set_accel(Gtk::Menu::AccelKey("<control>T"));	215	info.set_accel(Gtk::AccelKey("<control>T"));
216	menus.push_back(info);	216	menus.push_back(info);
217		217
218	info = Item(_("Append File"),	218	info = Item(_("Append File"),
219	slot(*this, &AudioCDView::appendFile),	219	mem_fun(*this, &AudioCDView::appendFile),
220	_("Append data from audio file to last track"));	220	_("Append data from audio file to last track"));
221	info.set_accel(Gtk::Menu::AccelKey("<control>F"));	221	info.set_accel(Gtk::AccelKey("<control>F"));
222	menus.push_back(info);	222	menus.push_back(info);
223		223
224	info = Item(_("Insert File"),	224	info = Item(_("Insert File"),
225	slot(*this, &AudioCDView::insertFile),	225	mem_fun(*this, &AudioCDView::insertFile),
226	_("Insert data from audio file at current marker position"));	226	_("Insert data from audio file at current marker position"));
227	info.set_accel(Gtk::Menu::AccelKey("<control>I"));	227	info.set_accel(Gtk::AccelKey("<control>I"));
228	menus.push_back(info);	228	menus.push_back(info);
229		229
230	menus.push_back(Separator());	230	menus.push_back(Separator());
231		231
232	menus.push_back(Item(_("Append Silence"),	232	menus.push_back(Item(_("Append Silence"),
233	slot(*this, &AudioCDView::appendSilence),	233	mem_fun(*this, &AudioCDView::appendSilence),
234	_("Append silence to last track")));	234	_("Append silence to last track")));
235		235
236	menus.push_back(Item(_("Insert Silence"),	236	menus.push_back(Item(_("Insert Silence"),
237	slot(*this, &AudioCDView::insertSilence),	237	mem_fun(*this, &AudioCDView::insertSilence),
238	_("Insert silence at current marker position")));	238	_("Insert silence at current marker position")));
239		239
240	Array<Info>& arrayInfo = project->insert_menus(_("Edit/CD-TEXT..."),	240	Array<Info>& arrayInfo = project->insert_menus(_("Edit/CD-TEXT..."),
Lines 475-485 Link Here
475	guiUpdate();	475	guiUpdate();
476	}	476	}
477		477
478	void	478	void
479	AudioCDView::drag_data_received_cb(const	479	AudioCDView::drag_data_received_cb(const Glib::RefPtr<Gdk::DragContext>& context,
480	Glib::RefPtr<Gdk::DragContext>& context,
481	gint x, gint y,	480	gint x, gint y,
482	GtkSelectionData *selection_data,	481	const GtkSelectionData *selection_data,
483	guint info, guint time)	482	guint info, guint time)
484	{	483	{
485	GList *names = NULL;	484	GList *names = NULL;

Lines 43-49 Link Here

(-)cdrdao-1.1.8/xdao/AudioCDView.h (-4 / +4 lines)
43	public:	43	public:
44	AudioCDView(AudioCDChild child, AudioCDProject project);	44	AudioCDView(AudioCDChild child, AudioCDProject project);
45	~AudioCDView();	45	~AudioCDView();
46	SigC::Signal0<void> add_view;	46	sigc::signal0<void> add_view;
47		47
48	void update(unsigned long level);	48	void update(unsigned long level);
49		49
Lines 104-112 Link Here
104	void selectionSet();	104	void selectionSet();
105		105
106	void drag_data_received_cb(const Glib::RefPtr<Gdk::DragContext>& context,	106	void drag_data_received_cb(const Glib::RefPtr<Gdk::DragContext>& context,
107	gint x, gint y, GtkSelectionData *selection_data,	107	gint x, gint y,
108	guint info, guint time);	108	const GtkSelectionData *selection_data,
109		109	guint info, guint time);
110	};	110	};
111		111
112	#endif	112	#endif

Lines 72-78 Link Here

(-)cdrdao-1.1.8/xdao/BlankCDDialog.cc (-7 / +7 lines)
72	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);	72	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
73	moreOptionsButton->add(*moreOptionsBox);	73	moreOptionsButton->add(*moreOptionsBox);
74	moreOptionsButton->signal_clicked().	74	moreOptionsButton->signal_clicked().
75	connect(slot(*this, &BlankCDDialog::moreOptions));	75	connect(mem_fun(*this, &BlankCDDialog::moreOptions));
76	moreOptionsBox = manage(new Gtk::HBox);	76	moreOptionsBox = manage(new Gtk::HBox);
77	frameBox->pack_start(*moreOptionsBox);	77	frameBox->pack_start(*moreOptionsBox);
78	moreOptionsBox->pack_end(*moreOptionsButton, false, false);	78	moreOptionsBox->pack_end(*moreOptionsButton, false, false);
Lines 88-94 Link Here
88	startBox->pack_start(*startLabel, false, false);	88	startBox->pack_start(*startLabel, false, false);
89		89
90	button->add(*startBox);	90	button->add(*startBox);
91	button->signal_clicked().connect(slot(*this, &BlankCDDialog::startAction));	91	button->signal_clicked().connect(mem_fun(*this, &BlankCDDialog::startAction));
92		92
93	Gtk::HBox *hbox2 = manage(new Gtk::HBox);	93	Gtk::HBox *hbox2 = manage(new Gtk::HBox);
94	hbox2->set_spacing(20);	94	hbox2->set_spacing(20);
Lines 97-103 Link Here
97		97
98	Gtk::Button* cancel_but =	98	Gtk::Button* cancel_but =
99	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));	99	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));
100	cancel_but->signal_clicked().connect(slot(*this, &BlankCDDialog::stop));	100	cancel_but->signal_clicked().connect(mem_fun(*this, &BlankCDDialog::stop));
101	hbox2->pack_start(*cancel_but);	101	hbox2->pack_start(*cancel_but);
102	vbox->pack_start(*hbox2, Gtk::PACK_SHRINK);	102	vbox->pack_start(*hbox2, Gtk::PACK_SHRINK);
103		103
Lines 107-115 Link Here
107	void BlankCDDialog::moreOptions()	107	void BlankCDDialog::moreOptions()
108	{	108	{
109	if (!moreOptionsDialog_) {	109	if (!moreOptionsDialog_) {
110	moreOptionsDialog_ = new Gtk::MessageDialog(*this, _("Blank options"),	110	moreOptionsDialog_ = new Gtk::MessageDialog(*this, _("Blank options"), false,
111	Gtk::MESSAGE_QUESTION,	111	Gtk::MESSAGE_QUESTION,
112	Gtk::BUTTONS_CLOSE);	112	Gtk::BUTTONS_CLOSE, true);
113		113
114	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();	114	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
115	Gtk::Frame *frame = new Gtk::Frame(_(" More Blank Options "));	115	Gtk::Frame *frame = new Gtk::Frame(_(" More Blank Options "));
Lines 137-149 Link Here
137	speedSpinButton_->set_digits(0);	137	speedSpinButton_->set_digits(0);
138	speedSpinButton_->set_sensitive(false);	138	speedSpinButton_->set_sensitive(false);
139	adjustment->signal_value_changed().	139	adjustment->signal_value_changed().
140	connect(slot(*this, &BlankCDDialog::speedChanged));	140	connect(mem_fun(*this, &BlankCDDialog::speedChanged));
141	hbox->pack_start(*speedSpinButton_, false, false, 10);	141	hbox->pack_start(*speedSpinButton_, false, false, 10);
142		142
143	speedButton_ = new Gtk::CheckButton(_("Use max."), 0);	143	speedButton_ = new Gtk::CheckButton(_("Use max."), 0);
144	speedButton_->set_active(true);	144	speedButton_->set_active(true);
145	speedButton_->signal_toggled().	145	speedButton_->signal_toggled().
146	connect(slot(*this, &BlankCDDialog::speedButtonChanged));	146	connect(mem_fun(*this, &BlankCDDialog::speedButtonChanged));
147	hbox->pack_start(*speedButton_, true, true);	147	hbox->pack_start(*speedButton_, true, true);
148	vbox->pack_start(*hbox);	148	vbox->pack_start(*hbox);
149	moreOptionsDialog_->show_all_children();	149	moreOptionsDialog_->show_all_children();

Lines 55-61 Link Here

(-)cdrdao-1.1.8/xdao/CdTextDialog.cc (-4 / +4 lines)
55	new Gtk::CheckButton(_("Enable Perfomer Entries"));	55	new Gtk::CheckButton(_("Enable Perfomer Entries"));
56	page_[i].performerButton->set_active(false);	56	page_[i].performerButton->set_active(false);
57	page_[i].performerButton->signal_toggled().	57	page_[i].performerButton->signal_toggled().
58	connect(bind(slot(*this, &CdTextDialog::activatePerformerAction), i));	58	connect(bind(mem_fun(*this, &CdTextDialog::activatePerformerAction), i));
59	page_[i].tracks = NULL;	59	page_[i].tracks = NULL;
60	page_[i].table->attach(*(new Gtk::Label(_("Performer"))), 1, 2, 0, 1);	60	page_[i].table->attach(*(new Gtk::Label(_("Performer"))), 1, 2, 0, 1);
61	page_[i].table->attach(*(new Gtk::Label(_("Title"))), 2, 3, 0, 1);	61	page_[i].table->attach(*(new Gtk::Label(_("Title"))), 2, 3, 0, 1);
Lines 108-122 Link Here
108		108
109	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));	109	applyButton_ = new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY));
110	bbox->pack_start(*applyButton_);	110	bbox->pack_start(*applyButton_);
111	applyButton_->signal_clicked().connect(slot(*this, &CdTextDialog::applyAction));	111	applyButton_->signal_clicked().connect(mem_fun(*this, &CdTextDialog::applyAction));
112		112
113	Gtk::Button *fillButton = new Gtk::Button(_(" Fill Performer "));	113	Gtk::Button *fillButton = new Gtk::Button(_(" Fill Performer "));
114	bbox->pack_start(*fillButton);	114	bbox->pack_start(*fillButton);
115	fillButton->signal_clicked().connect(slot(*this, &CdTextDialog::fillPerformerAction));	115	fillButton->signal_clicked().connect(mem_fun(*this, &CdTextDialog::fillPerformerAction));
116		116
117	Gtk::Button *cancelButton = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));	117	Gtk::Button *cancelButton = new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE));
118	bbox->pack_start(*cancelButton);	118	bbox->pack_start(*cancelButton);
119	cancelButton->signal_clicked().connect(slot(*this, &CdTextDialog::stop));	119	cancelButton->signal_clicked().connect(mem_fun(*this, &CdTextDialog::stop));
120		120
121	get_action_area()->pack_start(*bbox);	121	get_action_area()->pack_start(*bbox);
122		122

Lines 65-78 Link Here

(-)cdrdao-1.1.8/xdao/DeviceConfDialog.cc (-9 / +9 lines)
65		65
66	selectedRow_ = list_.get_selection()->get_selected();	66	selectedRow_ = list_.get_selection()->get_selected();
67	list_.get_selection()->signal_changed().	67	list_.get_selection()->signal_changed().
68	connect(slot(*this, &DeviceConfDialog::selectionChanged));	68	connect(mem_fun(*this, &DeviceConfDialog::selectionChanged));
69		69
70	Gtk::Menu *dmenu = manage(new Gtk::Menu);	70	Gtk::Menu *dmenu = manage(new Gtk::Menu);
71	Gtk::MenuItem *mi;	71	Gtk::MenuItem *mi;
72		72
73	for (i = 0; i <= CdDevice::maxDriverId(); i++) {	73	for (i = 0; i <= CdDevice::maxDriverId(); i++) {
74	mi = manage(new Gtk::MenuItem(CdDevice::driverName(i)));	74	mi = manage(new Gtk::MenuItem(CdDevice::driverName(i)));
75	mi->signal_activate().connect(bind(slot(*this,	75	mi->signal_activate().connect(bind(mem_fun(*this,
76	&DeviceConfDialog::setDriverId),	76	&DeviceConfDialog::setDriverId),
77	i));	77	i));
78	mi->show();	78	mi->show();
Lines 87-93 Link Here
87	for (i = 0; i <= MAX_DEVICE_TYPE_ID; i++) {	87	for (i = 0; i <= MAX_DEVICE_TYPE_ID; i++) {
88	mi = manage(new	88	mi = manage(new
89	Gtk::MenuItem(CdDevice::deviceType2string(ID2DEVICE_TYPE[i])));	89	Gtk::MenuItem(CdDevice::deviceType2string(ID2DEVICE_TYPE[i])));
90	mi->signal_activate().connect(bind(slot(*this,	90	mi->signal_activate().connect(bind(mem_fun(*this,
91	&DeviceConfDialog::setDeviceType),	91	&DeviceConfDialog::setDeviceType),
92	i));	92	i));
93	mi->show();	93	mi->show();
Lines 127-138 Link Here
127	button = manage(new Gtk::Button(_("Rescan")));	127	button = manage(new Gtk::Button(_("Rescan")));
128	bbox->pack_start(*button);	128	bbox->pack_start(*button);
129	button->signal_clicked().	129	button->signal_clicked().
130	connect(SigC::slot(*this,&DeviceConfDialog::rescanAction));	130	connect(sigc::mem_fun(*this,&DeviceConfDialog::rescanAction));
131		131
132	button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::DELETE)));	132	button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::DELETE)));
133	bbox->pack_start(*button);	133	bbox->pack_start(*button);
134	button->signal_clicked().	134	button->signal_clicked().
135	connect(SigC::slot(*this,&DeviceConfDialog::deleteDeviceAction));	135	connect(sigc::mem_fun(*this,&DeviceConfDialog::deleteDeviceAction));
136		136
137	listBox->pack_start(*bbox, Gtk::PACK_SHRINK);	137	listBox->pack_start(*bbox, Gtk::PACK_SHRINK);
138		138
Lines 193-199 Link Here
193	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::ADD)));	193	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::ADD)));
194	bbox->pack_start(*addButton);	194	bbox->pack_start(*addButton);
195	addButton->signal_clicked().	195	addButton->signal_clicked().
196	connect(slot(*this, &DeviceConfDialog::addDeviceAction));	196	connect(mem_fun(*this, &DeviceConfDialog::addDeviceAction));
197	addDeviceBox->pack_start(*bbox);	197	addDeviceBox->pack_start(*bbox);
198		198
199	addDeviceFrame_.add(*addDeviceBox);	199	addDeviceFrame_.add(*addDeviceBox);
Lines 207-224 Link Here
207	Gtk::Button* applyButton =	207	Gtk::Button* applyButton =
208	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));	208	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));
209	bbox->pack_start(*applyButton);	209	bbox->pack_start(*applyButton);
210	applyButton->signal_clicked().connect(slot(*this,	210	applyButton->signal_clicked().connect(mem_fun(*this,
211	&DeviceConfDialog::applyAction));	211	&DeviceConfDialog::applyAction));
212		212
213	Gtk::Button *resetButton = manage(new Gtk::Button(_("Reset")));	213	Gtk::Button *resetButton = manage(new Gtk::Button(_("Reset")));
214	bbox->pack_start(*resetButton);	214	bbox->pack_start(*resetButton);
215	resetButton->signal_clicked().connect(slot(*this,	215	resetButton->signal_clicked().connect(mem_fun(*this,
216	&DeviceConfDialog::resetAction));	216	&DeviceConfDialog::resetAction));
217		217
218	Gtk::Button *cancelButton =	218	Gtk::Button *cancelButton =
219	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));	219	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));
220	bbox->pack_start(*cancelButton);	220	bbox->pack_start(*cancelButton);
221	cancelButton->signal_clicked().connect(slot(*this,	221	cancelButton->signal_clicked().connect(mem_fun(*this,
222	&DeviceConfDialog::closeAction));	222	&DeviceConfDialog::closeAction));
223		223
224	contents->pack_start(*bbox, Gtk::PACK_SHRINK);	224	contents->pack_start(*bbox, Gtk::PACK_SHRINK);

Lines 65-91 Link Here

(-)cdrdao-1.1.8/xdao/Project.cc (-21 / +21 lines)
65	using namespace Gnome::UI::Items;	65	using namespace Gnome::UI::Items;
66	using namespace Gnome::UI::MenuItems;	66	using namespace Gnome::UI::MenuItems;
67	fileMenuTree.push_back(New(_("New..."), _("Create a new project"),	67	fileMenuTree.push_back(New(_("New..."), _("Create a new project"),
68	slot(*gcdmaster,	68	mem_fun(*gcdmaster,
69	&GCDMaster::newChooserWindow)));	69	&GCDMaster::newChooserWindow)));
70		70
71	// File->New menu	71	// File->New menu
72	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),	72	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
73	_("_Audio CD"),	73	_("_Audio CD"),
74	bind(slot(*gcdmaster,	74	bind(mem_fun(*gcdmaster,
75	&GCDMaster::newAudioCDProject2),	75	&GCDMaster::newAudioCDProject2),
76	(ProjectChooser *)NULL),	76	(ProjectChooser *)NULL),
77	_("New Audio CD")));	77	_("New Audio CD")));
78		78
79	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),	79	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
80	_("_Duplicate CD"),	80	_("_Duplicate CD"),
81	bind(slot(*gcdmaster,	81	bind(mem_fun(*gcdmaster,
82	&GCDMaster::newDuplicateCDProject),	82	&GCDMaster::newDuplicateCDProject),
83	(ProjectChooser *)NULL),	83	(ProjectChooser *)NULL),
84	_("Make a copy of a CD")));	84	_("Make a copy of a CD")));
85		85
86	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),	86	newMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::NEW)),
87	_("_Copy CD to disk"),	87	_("_Copy CD to disk"),
88	bind(slot(*gcdmaster,	88	bind(mem_fun(*gcdmaster,
89	&GCDMaster::newDumpCDProject),	89	&GCDMaster::newDumpCDProject),
90	(ProjectChooser *)NULL),	90	(ProjectChooser *)NULL),
91	_("Dump CD to disk")));	91	_("Dump CD to disk")));
Lines 101-128 Link Here
101	guint posFileSaveAs;	101	guint posFileSaveAs;
102	{	102	{
103	using namespace Gnome::UI::MenuItems;	103	using namespace Gnome::UI::MenuItems;
104	fileMenuTree.push_back(Open(bind(slot(*gcdmaster,	104	fileMenuTree.push_back(Open(bind(mem_fun(*gcdmaster,
105	&GCDMaster::openProject),	105	&GCDMaster::openProject),
106	(ProjectChooser *)0)));	106	(ProjectChooser *)0)));
107	fileMenuTree.push_back(Save(slot(*this, &Project::saveProject)));	107	fileMenuTree.push_back(Save(mem_fun(*this, &Project::saveProject)));
108	posFileSave = fileMenuTree.size() - 1;	108	posFileSave = fileMenuTree.size() - 1;
109	fileMenuTree.push_back(SaveAs(slot(*this, &Project::saveAsProject)));	109	fileMenuTree.push_back(SaveAs(mem_fun(*this, &Project::saveAsProject)));
110	posFileSaveAs = fileMenuTree.size() - 1;	110	posFileSaveAs = fileMenuTree.size() - 1;
111		111
112	fileMenuTree.push_back(Gnome::UI::Items::Separator());	112	fileMenuTree.push_back(Gnome::UI::Items::Separator());
113		113
114	// fileMenuTree.push_back(PrintSetup(slot(*this, &Project::nothing_cb)));	114	// fileMenuTree.push_back(PrintSetup(mem_fun(*this, &Project::nothing_cb)));
115	//	115	//
116	// fileMenuTree.push_back(Gnome::UI::Item(Gnome::UI::Icon(GNOME_STOCK_MENU_PRINT),	116	// fileMenuTree.push_back(Gnome::UI::Item(Gnome::UI::Icon(GNOME_STOCK_MENU_PRINT),
117	// "Print Cover...",	117	// "Print Cover...",
118	// slot(*this, &Project::nothing_cb),	118	// mem_fun(*this, &Project::nothing_cb),
119	// "Print Cover"));	119	// "Print Cover"));
120	//	120	//
121	// fileMenuTree.push_back(Gnome::UI::Items::Separator());	121	// fileMenuTree.push_back(Gnome::UI::Items::Separator());
122		122
123	// Close the current child (project);	123	// Close the current child (project);
124	fileMenuTree.push_back(Close(bind(slot(*gcdmaster, &GCDMaster::closeProject), this)));	124	fileMenuTree.push_back(Close(bind(mem_fun(*gcdmaster, &GCDMaster::closeProject), this)));
125	fileMenuTree.push_back(Exit(bind(slot(*gcdmaster, &GCDMaster::appClose), this)));	125	fileMenuTree.push_back(Exit(bind(mem_fun(*gcdmaster, &GCDMaster::appClose), this)));
126	}	126	}
127		127
128	guint posActionsRecord;	128	guint posActionsRecord;
Lines 132-174 Link Here
132	editMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),	132	editMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PROPERTIES)),
133	_("Project Info..."),	133	_("Project Info..."),
134		134
135	slot(*this, &Project::projectInfo),	135	mem_fun(*this, &Project::projectInfo),
136	_("Edit global project data")));	136	_("Edit global project data")));
137		137
138	// Actions menu	138	// Actions menu
139	actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),	139	actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),
140	_("_Record"),	140	_("_Record"),
141	slot(*this, &Project::recordToc2CD),	141	mem_fun(*this, &Project::recordToc2CD),
142	_("Record")));	142	_("Record")));
143	posActionsRecord = actionsMenuTree.size() - 1;	143	posActionsRecord = actionsMenuTree.size() - 1;
144		144
145	actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),	145	actionsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::CDROM)),
146	_("Blank CD-RW"),	146	_("Blank CD-RW"),
147	bind(slot(*gcdmaster,	147	bind(mem_fun(*gcdmaster,
148	&GCDMaster::blankCDRW),	148	&GCDMaster::blankCDRW),
149	this),	149	this),
150	_("Erase a CD-RW")));	150	_("Erase a CD-RW")));
151		151
152	// actionsMenuTree.push_back(Gnome::UI::Item("Fixate CD",	152	// actionsMenuTree.push_back(Gnome::UI::Item("Fixate CD",
153	// slot(*this, &Project::nothing_cb)));	153	// mem_fun(*this, &Project::nothing_cb)));
154	// actionsMenuTree.push_back(Gnome::UI::Item("Get Info",	154	// actionsMenuTree.push_back(Gnome::UI::Item("Get Info",
155	// slot(*this, &Project::nothing_cb)));	155	// mem_fun(*this, &Project::nothing_cb)));
156		156
157	// Settings menu	157	// Settings menu
158	settingsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PREFERENCES)),	158	settingsMenuTree.push_back(Item(Icon(Gtk::StockID(Gtk::Stock::PREFERENCES)),
159	_("Configure Devices..."),	159	_("Configure Devices..."),
160	slot(*gcdmaster, &GCDMaster::configureDevices)));	160	mem_fun(*gcdmaster, &GCDMaster::configureDevices)));
161	}	161	}
162		162
163	// settingsMenuTree.push_back(Gnome::UI::MenuItems::Preferences	163	// settingsMenuTree.push_back(Gnome::UI::MenuItems::Preferences
164	// (slot(*this, &Project::nothing_cb)));	164	// (mem_fun(*this, &Project::nothing_cb)));
165		165
166		166
167	// Help menu	167	// Help menu
168	//helpMenuTree.push_back(Gnome::UI::Help("Quick Start"));	168	//helpMenuTree.push_back(Gnome::UI::Help("Quick Start"));
169		169
170	helpMenuTree.push_back(Gnome::UI::MenuItems::About	170	helpMenuTree.push_back(Gnome::UI::MenuItems::About
171	(slot(*this, &Project::aboutDialog)));	171	(mem_fun(*this, &Project::aboutDialog)));
172		172
173	{	173	{
174	using namespace Gnome::UI::Menus;	174	using namespace Gnome::UI::Menus;
Lines 261-269 Link Here
261	if (!saveFileSelector_) {	261	if (!saveFileSelector_) {
262	saveFileSelector_ = new Gtk::FileSelection(_("Save Project"));	262	saveFileSelector_ = new Gtk::FileSelection(_("Save Project"));
263	saveFileSelector_->get_ok_button()->signal_clicked().	263	saveFileSelector_->get_ok_button()->signal_clicked().
264	connect(slot(*this, &Project::saveFileSelectorOKCB));	264	connect(mem_fun(*this, &Project::saveFileSelectorOKCB));
265	saveFileSelector_->get_cancel_button()->signal_clicked().	265	saveFileSelector_->get_cancel_button()->signal_clicked().
266	connect(slot(*this, &Project::saveFileSelectorCancelCB));	266	connect(mem_fun(*this, &Project::saveFileSelectorCancelCB));
267	saveFileSelector_->set_transient_for(*this);	267	saveFileSelector_->set_transient_for(*this);
268	}	268	}
269		269

Lines 79-91 Link Here

(-)cdrdao-1.1.8/xdao/ProjectChooser.cc (-4 / +4 lines)
79		79
80	// Connect button signals	80	// Connect button signals
81	openButton.signal_clicked().	81	openButton.signal_clicked().
82	connect(bind(slot(*gcdmaster, &GCDMaster::openProject), this));	82	connect(bind(mem_fun(*gcdmaster, &GCDMaster::openProject), this));
83	audioCDButton.signal_clicked().	83	audioCDButton.signal_clicked().
84	connect(bind(slot(*gcdmaster, &GCDMaster::newAudioCDProject2), this));	84	connect(bind(mem_fun(*gcdmaster, &GCDMaster::newAudioCDProject2), this));
85	copyCDButton.signal_clicked().	85	copyCDButton.signal_clicked().
86	connect(bind(slot(*gcdmaster, &GCDMaster::newDuplicateCDProject), this));	86	connect(bind(mem_fun(*gcdmaster, &GCDMaster::newDuplicateCDProject), this));
87	dumpCDButton.signal_clicked().	87	dumpCDButton.signal_clicked().
88	connect(bind(slot(*gcdmaster, &GCDMaster::newDumpCDProject), this));	88	connect(bind(mem_fun(*gcdmaster, &GCDMaster::newDumpCDProject), this));
89		89
90	vbox.show_all();	90	vbox.show_all();
91	}	91	}

Lines 71-83 Link Here

(-)cdrdao-1.1.8/xdao/RecordCDTarget.cc (-6 / +6 lines)
71	speedSpinButton_->set_digits(0);	71	speedSpinButton_->set_digits(0);
72	speedSpinButton_->show();	72	speedSpinButton_->show();
73	speedSpinButton_->set_sensitive(false);	73	speedSpinButton_->set_sensitive(false);
74	adjustment->signal_value_changed().connect(SigC::slot(*this, &RecordCDTarget::speedChanged));	74	adjustment->signal_value_changed().connect(sigc::mem_fun(*this, &RecordCDTarget::speedChanged));
75	hbox->pack_start(*speedSpinButton_, false, false, 10);	75	hbox->pack_start(*speedSpinButton_, false, false, 10);
76		76
77	speedButton_ = new Gtk::CheckButton("Use max.", 0);	77	speedButton_ = new Gtk::CheckButton("Use max.", 0);
78	speedButton_->set_active(true);	78	speedButton_->set_active(true);
79	speedButton_->show();	79	speedButton_->show();
80	speedButton_->signal_toggled().connect(SigC::slot(*this, &RecordCDTarget::speedButtonChanged));	80	speedButton_->signal_toggled().connect(sigc::mem_fun(*this, &RecordCDTarget::speedButtonChanged));
81	hbox->pack_start(*speedButton_, true, true);	81	hbox->pack_start(*speedButton_, true, true);
82	vbox->pack_start(*hbox);	82	vbox->pack_start(*hbox);
83		83
Lines 104-110 Link Here
104	moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);	104	moreOptionsBox->pack_start(*moreOptionsPixmap, false, false, 3);
105	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);	105	moreOptionsBox->pack_start(*moreOptionsLabel, false, false, 4);
106	moreOptionsButton->add(*moreOptionsBox);	106	moreOptionsButton->add(*moreOptionsBox);
107	moreOptionsButton->signal_clicked().connect(slot(*this, &RecordCDTarget::moreOptions));	107	moreOptionsButton->signal_clicked().connect(mem_fun(*this, &RecordCDTarget::moreOptions));
108	moreOptionsPixmap->show();	108	moreOptionsPixmap->show();
109	moreOptionsLabel->show();	109	moreOptionsLabel->show();
110	moreOptionsBox->show();	110	moreOptionsBox->show();
Lines 145-153 Link Here
145	{	145	{
146	if (!moreOptionsDialog_)	146	if (!moreOptionsDialog_)
147	{	147	{
148	moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, "Target options",	148	moreOptionsDialog_ = new Gtk::MessageDialog(*parent_, "Target options",false,
149	Gtk::MESSAGE_QUESTION,	149	Gtk::MESSAGE_QUESTION,
150	Gtk::BUTTONS_CLOSE);	150	Gtk::BUTTONS_CLOSE, true);
151		151
152	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();	152	Gtk::VBox *vbox = moreOptionsDialog_->get_vbox();
153	Gtk::Frame *frame = new Gtk::Frame(" More Target Options ");	153	Gtk::Frame *frame = new Gtk::Frame(" More Target Options ");
Lines 188-194 Link Here
188	bufferRAMLabel_ = new Gtk::Label("= 1.72 Mb buffer.", 0);	188	bufferRAMLabel_ = new Gtk::Label("= 1.72 Mb buffer.", 0);
189	hbox->pack_start(*bufferRAMLabel_, true, true);	189	hbox->pack_start(*bufferRAMLabel_, true, true);
190	adjustment->signal_value_changed().	190	adjustment->signal_value_changed().
191	connect(SigC::slot(*this, &RecordCDTarget::updateBufferRAMLabel));	191	connect(sigc::mem_fun(*this, &RecordCDTarget::updateBufferRAMLabel));
192		192
193	vbox->pack_start(*hbox);	193	vbox->pack_start(*hbox);
194	}	194	}

Lines 81-92 Link Here

(-)cdrdao-1.1.8/xdao/RecordTocDialog.cc (-2 / +2 lines)
81	startBox->pack_start(*startLabel, false, false);	81	startBox->pack_start(*startLabel, false, false);
82		82
83	button->add(*startBox);	83	button->add(*startBox);
84	button->signal_clicked().connect(slot(*this, &RecordTocDialog::startAction));	84	button->signal_clicked().connect(mem_fun(*this, &RecordTocDialog::startAction));
85	hbox->pack_start(*button);	85	hbox->pack_start(*button);
86		86
87	Gtk::Button* cancel_but =	87	Gtk::Button* cancel_but =
88	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));	88	manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CANCEL)));
89	cancel_but->signal_clicked().connect(slot(*this, &Gtk::Widget::hide));	89	cancel_but->signal_clicked().connect(mem_fun(*this, &Gtk::Widget::hide));
90	hbox->pack_start(*cancel_but);	90	hbox->pack_start(*cancel_but);
91		91
92	vbox->pack_start(*hbox, Gtk::PACK_SHRINK);	92	vbox->pack_start(*hbox, Gtk::PACK_SHRINK);

Lines 190-202 Link Here

(-)cdrdao-1.1.8/xdao/SampleDisplay.h (-7 / +7 lines)
190		190
191	void updateToc(unsigned long, unsigned long);	191	void updateToc(unsigned long, unsigned long);
192		192
193	SigC::Signal1<void, unsigned long> markerSet;	193	sigc::signal1<void, unsigned long> markerSet;
194	SigC::Signal1<void, unsigned long> cursorMoved;	194	sigc::signal1<void, unsigned long> cursorMoved;
195	SigC::Signal2<void, unsigned long, unsigned long> selectionSet;	195	sigc::signal2<void, unsigned long, unsigned long> selectionSet;
196	SigC::Signal0<void> selectionCleared;	196	sigc::signal0<void> selectionCleared;
197	SigC::Signal3<void, const Track *, int, int> trackMarkSelected;	197	sigc::signal3<void, const Track *, int, int> trackMarkSelected;
198	SigC::Signal4<void, const Track *, int, int, unsigned long> trackMarkMoved;	198	sigc::signal4<void, const Track *, int, int, unsigned long> trackMarkMoved;
199	SigC::Signal2<void, unsigned long, unsigned long> viewModified;	199	sigc::signal2<void, unsigned long, unsigned long> viewModified;
200		200
201	protected:	201	protected:
202	bool handle_configure_event (GdkEventConfigure *);	202	bool handle_configure_event (GdkEventConfigure *);

Lines 94-100 Link Here

(-)cdrdao-1.1.8/xdao/SampleManager.cc (-3 / +3 lines)
94		94
95	#include "TrackDataScrap.h"	95	#include "TrackDataScrap.h"
96		96
97	class SampleManagerImpl : public SigC::Object {	97	class SampleManagerImpl : public sigc::trackable {
98	public:	98	public:
99	SampleManagerImpl(unsigned long);	99	SampleManagerImpl(unsigned long);
100	~SampleManagerImpl();	100	~SampleManagerImpl();
Lines 225-231 Link Here
225	void SampleManagerImpl::setAbortButton(Gtk::Button* button)	225	void SampleManagerImpl::setAbortButton(Gtk::Button* button)
226	{	226	{
227	abortButton_ = button;	227	abortButton_ = button;
228	button->signal_clicked().connect(slot(*this,	228	button->signal_clicked().connect(mem_fun(*this,
229	&SampleManagerImpl::abortAction));	229	&SampleManagerImpl::abortAction));
230	}	230	}
231		231
Lines 340-346 Link Here
340	if (withGui_) {	340	if (withGui_) {
341	if (progressBar_) progressBar_->set_fraction(0.0);	341	if (progressBar_) progressBar_->set_fraction(0.0);
342	if (abortButton_) abortButton_->set_sensitive(true);	342	if (abortButton_) abortButton_->set_sensitive(true);
343	Glib::signal_idle().connect(slot(*this, &SampleManagerImpl::readSamples));	343	Glib::signal_idle().connect(mem_fun(*this, &SampleManagerImpl::readSamples));
344	tocEdit_->blockEdit();	344	tocEdit_->blockEdit();
345	} else {	345	} else {
346	while (readSamples());	346	while (readSamples());

Lines 136-158 Link Here

(-)cdrdao-1.1.8/xdao/TocInfoDialog.cc (-8 / +8 lines)
136		136
137	mi = manage(new Gtk::MenuItem("CD-DA"));	137	mi = manage(new Gtk::MenuItem("CD-DA"));
138	mi->signal_activate().	138	mi->signal_activate().
139	connect(bind(slot(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_DA));	139	connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_DA));
140	menu->append(*mi);	140	menu->append(*mi);
141		141
142	mi = manage(new Gtk::MenuItem("CD-ROM"));	142	mi = manage(new Gtk::MenuItem("CD-ROM"));
143	mi->signal_activate().	143	mi->signal_activate().
144	connect(bind(slot(*this, &TocInfoDialog::setSelectedTocType),Toc::CD_ROM));	144	connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType),Toc::CD_ROM));
145	menu->append(*mi);	145	menu->append(*mi);
146		146
147	mi = manage(new Gtk::MenuItem("CD-ROM-XA"));	147	mi = manage(new Gtk::MenuItem("CD-ROM-XA"));
148	mi->signal_activate().	148	mi->signal_activate().
149	connect(bind(slot(*this, &TocInfoDialog::setSelectedTocType),	149	connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType),
150	Toc::CD_ROM_XA));	150	Toc::CD_ROM_XA));
151	menu->append(*mi);	151	menu->append(*mi);
152		152
153	mi = manage(new Gtk::MenuItem("CD-I"));	153	mi = manage(new Gtk::MenuItem("CD-I"));
154	mi->signal_activate().	154	mi->signal_activate().
155	connect(bind(slot(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_I));	155	connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedTocType), Toc::CD_I));
156	menu->append(*mi);	156	menu->append(*mi);
157		157
158	tocType_ = manage(new Gtk::OptionMenu);	158	tocType_ = manage(new Gtk::OptionMenu);
Lines 216-226 Link Here
216		216
217	applyButton_ = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));	217	applyButton_ = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::APPLY)));
218	bbox->pack_start(*applyButton_);	218	bbox->pack_start(*applyButton_);
219	applyButton_->signal_clicked().connect(SigC::slot(*this,&TocInfoDialog::applyAction));	219	applyButton_->signal_clicked().connect(sigc::mem_fun(*this,&TocInfoDialog::applyAction));
220		220
221	button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));	221	button = manage(new Gtk::Button(Gtk::StockID(Gtk::Stock::CLOSE)));
222	bbox->pack_start(*button);	222	bbox->pack_start(*button);
223	button->signal_clicked().connect(SigC::slot(*this,&TocInfoDialog::closeAction));	223	button->signal_clicked().connect(sigc::mem_fun(*this,&TocInfoDialog::closeAction));
224		224
225	get_action_area()->pack_start(*bbox);	225	get_action_area()->pack_start(*bbox);
226	show_all_children();	226	show_all_children();
Lines 321-327 Link Here
321	bval.value = i;	321	bval.value = i;
322		322
323	mi = manage(new Gtk::MenuItem(CD_TEXT_LANGUAGE_CODES[i].name));	323	mi = manage(new Gtk::MenuItem(CD_TEXT_LANGUAGE_CODES[i].name));
324	mi->signal_activate().connect(bind(slot(*this, &TocInfoDialog::setSelectedCDTextLanguage), bval));	324	mi->signal_activate().connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedCDTextLanguage), bval));
325	mi->show();	325	mi->show();
326	menu->append(*mi);	326	menu->append(*mi);
327	}	327	}
Lines 344-350 Link Here
344	bval.value = i;	344	bval.value = i;
345		345
346	mi = manage(new Gtk::MenuItem(CD_TEXT_GENRE_CODES[i].name));	346	mi = manage(new Gtk::MenuItem(CD_TEXT_GENRE_CODES[i].name));
347	mi->signal_activate().connect(bind(slot(*this, &TocInfoDialog::setSelectedCDTextGenre), bval));	347	mi->signal_activate().connect(bind(mem_fun(*this, &TocInfoDialog::setSelectedCDTextGenre), bval));
348	mi->show();	348	mi->show();
349	menu->append(*mi);	349	menu->append(*mi);
350	}	350	}