juk.cpp 20.5 KB
Newer Older
1 2 3 4 5
/***************************************************************************
                          juk.cpp  -  description
                             -------------------
    begin                : Mon Feb  4 23:40:41 EST 2002
    copyright            : (C) 2002 by Scott Wheeler
6
    email                : wheeler@kde.org
7
***************************************************************************/
8 9 10 11 12 13 14 15 16 17

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

18
#include <kapplication.h>
19
#include <klocale.h>
20
#include <kiconloader.h>
21
#include <kcmdlineargs.h>
22
#include <kstatusbar.h>
23
#include <kconfig.h>
24
#include <kdebug.h>
25
#include <kmessagebox.h>
26

27 28
#include <qtimer.h>
#include <qlistview.h>
29
#include <qinputdialog.h>
30
#include <qslider.h>
31 32
#include <qstrlist.h>
#include <qmetaobject.h>
33

34
#include "juk.h"
35
#include "slideraction.h"
36
#include "cache.h"
37
#include "statuslabel.h"
38 39
#include "splashscreen.h"
#include "genrelisteditor.h"
40
#include "systemtray.h"
41 42 43 44 45

////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////

46 47
JuK::JuK(QWidget *parent, const char *name) : KMainWindow(parent, name, WDestructiveClose),
					      m_shuttingDown(false)
48
{
49 50 51
    SplashScreen::instance()->show();
    kapp->processEvents();
 
52 53
    // Expect segfaults if you change this order.

54
    readSettings();
55
    setupLayout();
56
    setupActions();
57
    slotPlaylistChanged();
58
    readConfig();
59
    setupPlayer();
60
    setupSystemTray();
61
    processArgs();
62

63
    SplashScreen::finishedLoading();
Scott Wheeler's avatar
Scott Wheeler committed
64
    QTimer::singleShot(0, CollectionList::instance(), SLOT(slotCheckCache()));
65 66 67 68
}

JuK::~JuK()
{
69

70 71 72 73 74 75
}

////////////////////////////////////////////////////////////////////////////////
// private members
////////////////////////////////////////////////////////////////////////////////

76 77
void JuK::setupLayout()
{
78 79
    m_splitter = new PlaylistSplitter(this, m_restore, "playlistSplitter");
    setCentralWidget(m_splitter);
80 81

    // playlist item activation connection
82 83
    connect(m_splitter, SIGNAL(signalDoubleClicked()), this, SLOT(slotPlaySelectedFile()));
    connect(m_splitter, SIGNAL(signalListBoxDoubleClicked()), this, SLOT(slotPlayFirstFile()));
84

85
    // create status bar
86 87
    m_statusLabel = new StatusLabel(statusBar());
    statusBar()->addWidget(m_statusLabel, 1);
88

89 90
    connect(m_splitter, SIGNAL(signalSelectedPlaylistCountChanged(int)), m_statusLabel, SLOT(setPlaylistCount(int)));
    connect(m_statusLabel, SIGNAL(jumpButtonClicked()), m_splitter, SLOT(slotSelectPlaying()));
91

92
    m_splitter->setFocus();
93

94
    resize(750, 500);
95 96
}

97 98
void JuK::setupActions()
{
99
    // file menu
100 101 102
    KStdAction::openNew(m_splitter, SLOT(slotCreatePlaylist()), actionCollection());
    KStdAction::open(m_splitter, SLOT(slotOpen()), actionCollection());
    new KAction(i18n("Open &Directory..."), "fileopen", 0, m_splitter, SLOT(slotOpenDirectory()), actionCollection(), "openDirectory");
103

104
    m_renamePlaylistAction = new KAction(i18n("Rename..."), 0, m_splitter, SLOT(slotRenamePlaylist()), 
105
					 actionCollection(), "renamePlaylist");
106
    new KAction(i18n("Duplicate..."), "editcopy", 0, m_splitter, SLOT(slotDuplicatePlaylist()), actionCollection(), "duplicatePlaylist");
107
    
108 109 110
    m_savePlaylistAction = KStdAction::save(m_splitter, SLOT(slotSavePlaylist()), actionCollection());
    m_saveAsPlaylistAction = KStdAction::saveAs(m_splitter, SLOT(slotSaveAsPlaylist()), actionCollection());
    m_deleteItemPlaylistAction = new KAction(i18n("Remove"), "edittrash", 0, m_splitter, SLOT(slotDeletePlaylist()), 
111
					     actionCollection(), "deleteItemPlaylist");
112

113
    KStdAction::quit(this, SLOT(slotQuit()), actionCollection());
114 115

    // edit menu
116
    KStdAction::cut(this, SLOT(cut()), actionCollection());
117 118 119 120
    KStdAction::copy(this, SLOT(copy()), actionCollection());
    KStdAction::paste(this, SLOT(paste()), actionCollection());
    new KAction(i18n("Clear"), "editclear", 0, this, SLOT(clear()), actionCollection(), "clear");
    KStdAction::selectAll(this, SLOT(selectAll()), actionCollection());
121

122
    // view menu
123 124 125 126
    m_showEditorAction = new KToggleAction(i18n("Show Tag Editor"), "edit", 0, actionCollection(), "showEditor");
    connect(m_showEditorAction, SIGNAL(toggled(bool)), m_splitter, SLOT(slotSetEditorVisible(bool)));
    KStdAction::redisplay(m_splitter, SLOT(slotRefresh()), actionCollection());
    actionCollection()->insert(m_splitter->columnVisibleAction());
127
    
128
    // play menu
129
    m_randomPlayAction = new KToggleAction(i18n("Random Play"), 0, actionCollection(), "randomPlay");
130 131 132 133 134
    m_playAction = new KAction(i18n("&Play"), "player_play", 0, this, SLOT(slotPlay()), actionCollection(), "play");
    m_pauseAction = new KAction(i18n("P&ause"), "player_pause", 0, this, SLOT(slotPause()), actionCollection(), "pause");
    m_stopAction = new KAction(i18n("&Stop"), "player_stop", 0, this, SLOT(slotStop()), actionCollection(), "stop");
    m_backAction = new KAction(i18n("Skip &Back"), "player_start", 0, this, SLOT(slotBack()), actionCollection(), "back");
    m_forwardAction = new KAction(i18n("Skip &Forward"), "player_end", 0, this, SLOT(slotForward()), actionCollection(), "forward");
135

136
    // tagger menu
137 138
    new KAction(i18n("Save"), "filesave", "CTRL+t", m_splitter, SLOT(slotSaveTag()), actionCollection(), "saveItem");
    new KAction(i18n("Delete"), "editdelete", 0, m_splitter, SLOT(slotDeleteSelectedItems()), actionCollection(), "removeItem");
139
    
140
    // settings menu
141 142 143
    new KToggleAction(i18n("Show Menu Bar"), "CTRL+m", this, SLOT(slotToggleMenuBar()), actionCollection(), "toggleMenuBar");
    new KToggleAction(i18n("Show Tool Bar"), "CTRL+b", this, SLOT(slotToggleToolBar()), actionCollection(), "toggleToolBar");

144
    m_restoreOnLoadAction = new KToggleAction(i18n("Restore Playlists on Load"),  0, actionCollection(), "restoreOnLoad");
145

146
    m_toggleSystemTrayAction = new KToggleAction(i18n("Dock in System Tray"), KShortcut(), actionCollection(), "toggleSystemTray");
147
    connect(m_toggleSystemTrayAction, SIGNAL(toggled(bool)), this, SLOT(slotToggleSystemTray(bool)));
148

149 150
    m_toggleDockOnCloseAction = new KToggleAction(i18n("Stay in System Tray on Close"), 0, actionCollection(), "dockOnClose");

151
    new KAction(i18n("Genre List Editor..."), 0, this, SLOT(slotShowGenreListEditor()), actionCollection(), "showGenreListEditor");
152

153

154 155 156
    m_outputSelectAction = Player::playerSelectAction(actionCollection());
    if(m_outputSelectAction) {
	m_outputSelectAction->setCurrentItem(0);
157
	connect(m_outputSelectAction, SIGNAL(activated(int)), this, SLOT(slotSetOutput(int)));
158
    }
159

160
    // just in the toolbar
161
    m_sliderAction = new SliderAction(i18n("Track Position"), actionCollection(), "trackPositionAction");
162 163

    createGUI();
164 165

    // set the slider to the proper orientation and make it stay that way
166 167
    m_sliderAction->slotUpdateOrientation();
    connect(this, SIGNAL(dockWindowPositionChanged(QDockWindow *)), m_sliderAction, SLOT(slotUpdateOrientation(QDockWindow *)));
168

169
    connect(m_splitter, SIGNAL(signalPlaylistChanged()), this, SLOT(slotPlaylistChanged()));
170 171
}

172
void JuK::setupSystemTray()
173
{
174 175 176
    if(m_toggleSystemTrayAction && m_toggleSystemTrayAction->isChecked()) {
	m_systemTray = new SystemTray(this, "systemTray");
	m_systemTray->show();
177
	
178 179 180 181 182
	connect(m_systemTray, SIGNAL(signalPlay()),    this, SLOT(slotPlay()));
	connect(m_systemTray, SIGNAL(signalStop()),    this, SLOT(slotStop()));
	connect(m_systemTray, SIGNAL(signalPause()),   this, SLOT(slotPause()));
	connect(m_systemTray, SIGNAL(signalBack()),    this, SLOT(slotBack()));
	connect(m_systemTray, SIGNAL(signalForward()), this, SLOT(slotForward()));
183

184
	connect(this, SIGNAL(signalNewSong(const QString&)), m_systemTray, SLOT(slotNewSong(const QString&)));
185
	
186 187 188 189
	if(m_player && m_player->paused())
	    m_systemTray->slotPause();
	else if(m_player && m_player->playing())
	    m_systemTray->slotPlay();
190 191
	
	m_toggleDockOnCloseAction->setEnabled(true);
192 193

	connect(m_systemTray, SIGNAL(quitSelected()), this, SLOT(slotQuit()));
194
    }
195
    else {
196
	m_systemTray = 0;
197 198
	m_toggleDockOnCloseAction->setEnabled(false);
    }
199 200
}

201 202
void JuK::setupPlayer()
{
203 204 205 206 207 208
    m_trackPositionDragging = false;
    m_noSeek = false;
    m_pauseAction->setEnabled(false);
    m_stopAction->setEnabled(false);
    m_backAction->setEnabled(false);
    m_forwardAction->setEnabled(false);
209

210
    m_playTimer = new QTimer(this);
211
    connect(m_playTimer, SIGNAL(timeout()), this, SLOT(slotPollPlay()));
212

213
    if(m_sliderAction && m_sliderAction->getTrackPositionSlider() && m_sliderAction->getVolumeSlider()) {
214 215 216
        connect(m_sliderAction->getTrackPositionSlider(), SIGNAL(valueChanged(int)), this, SLOT(slotTrackPositionSliderUpdate(int)));
        connect(m_sliderAction->getTrackPositionSlider(), SIGNAL(sliderPressed()), this, SLOT(slotTrackPositionSliderClicked()));
        connect(m_sliderAction->getTrackPositionSlider(), SIGNAL(sliderReleased()), this, SLOT(slotTrackPositionSliderReleased()));
217
        m_sliderAction->getTrackPositionSlider()->setEnabled(false);
218

219
        connect(m_sliderAction->getVolumeSlider(), SIGNAL(valueChanged(int)), this, SLOT(slotSetVolume(int)));
220
    }
221 222
    
    int playerType = 0;
223 224
    if(m_outputSelectAction) {
	playerType = m_outputSelectAction->currentItem();
225
	connect(m_outputSelectAction, SIGNAL(activated(int)), this, SLOT(slotSetOutput(int)));
226 227
    }

228
    m_player = Player::createPlayer(playerType);
229 230
}

231

232 233 234 235 236 237 238 239
void JuK::processArgs()
{
    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
    QStringList files;
    
    for(int i = 0; i < args->count(); i++)
	files.append(args->arg(i));

240
    m_splitter->open(files);
241 242
}

243 244 245 246 247 248 249 250 251
/**
 * These are settings that need to be know before setting up the GUI.
 */

void JuK::readSettings()
{
    KConfig *config = KGlobal::config();
    { // general settings
        KConfigGroupSaver saver(config, "Settings");
252
	m_restore = config->readBoolEntry("RestoreOnLoad", true);
253 254 255
    }
}

256 257
void JuK::readConfig()
{
258
    // Automagically save and m_restore many window settings.
259 260
    setAutoSaveSettings();

261
    KConfig *config = KGlobal::config();
262
    { // m_player settings
263
        KConfigGroupSaver saver(config, "Player");
264 265 266
        if(m_sliderAction && m_sliderAction->getVolumeSlider()) {
            int volume = config->readNumEntry("Volume", m_sliderAction->getVolumeSlider()->maxValue());
            m_sliderAction->getVolumeSlider()->setValue(volume);
267
        }
268
	if(m_randomPlayAction) {
269
	    bool randomPlay = config->readBoolEntry("RandomPlay", false);
270
	    m_randomPlayAction->setChecked(randomPlay);
271
	}
272
    }
273
    { // view settings
274
        KConfigGroupSaver saver(config, "View");
275
	bool showEditor = config->readBoolEntry("ShowEditor", false);
276 277
	m_showEditorAction->setChecked(showEditor);
	m_splitter->slotSetEditorVisible(showEditor);
278
    }
279 280
    { // general settings
        KConfigGroupSaver saver(config, "Settings");
281

282
	bool dockInSystemTray = config->readBoolEntry("DockInSystemTray", true);
283
	m_toggleSystemTrayAction->setChecked(dockInSystemTray);
284
	
285 286 287
	bool dockOnClose = config->readBoolEntry("DockOnClose", true);
	m_toggleDockOnCloseAction->setChecked(dockOnClose);

288 289
	if(m_outputSelectAction)
	    m_outputSelectAction->setCurrentItem(config->readNumEntry("MediaSystem", 0));
290
	
291
    }
292

293 294
    if(m_restoreOnLoadAction)
	m_restoreOnLoadAction->setChecked(m_restore);
295
    
296 297 298 299
}

void JuK::saveConfig()
{
300
    KConfig *config = KGlobal::config();
301
    { // m_player settings
302
        KConfigGroupSaver saver(config, "Player");
303 304 305 306
        if(m_sliderAction && m_sliderAction->getVolumeSlider())
            config->writeEntry("Volume", m_sliderAction->getVolumeSlider()->value());
	if(m_randomPlayAction)
	    config->writeEntry("RandomPlay", m_randomPlayAction->isChecked());
307
    }
308 309
    { // view settings
        KConfigGroupSaver saver(config, "View");
310
	config->writeEntry("ShowEditor", m_showEditorAction->isChecked());
311
    }
312 313
    { // general settings
        KConfigGroupSaver saver(config, "Settings");
314 315 316 317
	if(m_restoreOnLoadAction)
	    config->writeEntry("RestoreOnLoad", m_restoreOnLoadAction->isChecked());
	if(m_toggleSystemTrayAction)
	    config->writeEntry("DockInSystemTray", m_toggleSystemTrayAction->isChecked());
318 319
	if(m_toggleDockOnCloseAction)
	    config->writeEntry("DockOnClose", m_toggleDockOnCloseAction->isChecked());
320 321
	if(m_outputSelectAction)
	    config->writeEntry("MediaSystem", m_outputSelectAction->currentItem());
322
    }
323 324
}

325
bool JuK::queryExit()
326
{
327
    slotStop();
328
    delete m_player;
329
    Cache::instance()->save();
330
    saveConfig();
331
    delete m_splitter;
332
    return true;
333 334
}

335 336
bool JuK::queryClose()
{
337
    if(!m_shuttingDown && m_systemTray && m_toggleDockOnCloseAction->isChecked()) {
338 339 340 341 342 343 344 345 346 347 348
	KMessageBox::information(this,
				 i18n("<qt>Closing the main window will keep JuK running in the system tray. "
				      "Use Quit from the File menu to quit the application.</qt>"), 
				 i18n("Docking in System Tray"), "hideOnCloseInfo");
	hide();
	return false;
    }
    else
	return true;
}

349 350 351 352 353 354 355 356 357 358 359 360 361
void JuK::invokeEditSlot( const char *slotName, const char *slot )
{
    QObject *object = focusWidget();
    
    if(!object || !slotName || !slot)
	return;
    
    QMetaObject *meta = object->metaObject();
    QStrList l = meta->slotNames(true);
  
    if(l.find(slotName) == -1)
	return;
    
362 363 364
    connect(this, SIGNAL(signalEdit()), object, slot);
    emit signalEdit();
    disconnect(this, SIGNAL(signalEdit()), object, slot);
365 366
}

367 368 369 370
QString JuK::playingString() const
{
    QString s;
    
371 372
    if(m_splitter->playingArtist().isEmpty())
	s = m_splitter->playingTrack().simplifyWhiteSpace();
373
    else
374
	s = m_splitter->playingArtist().simplifyWhiteSpace() + " - " + m_splitter->playingTrack().simplifyWhiteSpace();
375 376 377 378

    return s;
}

379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
void JuK::updatePlaylistInfo()
{
    m_statusLabel->setPlaylistInfo(m_splitter->selectedPlaylistName(), m_splitter->selectedPlaylistCount());
}

void JuK::play(const QString &file)
{
    if(!m_player)
	return;

    float volume = float(m_sliderAction->getVolumeSlider()->value()) / float(m_sliderAction->getVolumeSlider()->maxValue());

    if(m_player->paused())
	m_player->stop();
    
    m_player->play(file, volume);

    // Make sure that the m_player actually starts before doing anything.

    if(m_player->playing()) {
	m_pauseAction->setEnabled(true);
	m_stopAction->setEnabled(true);
	
	m_backAction->setEnabled(true);
	m_forwardAction->setEnabled(true);
	
	m_sliderAction->getTrackPositionSlider()->setValue(0);
	m_sliderAction->getTrackPositionSlider()->setEnabled(true);
	m_playTimer->start(m_pollInterval);

	m_statusLabel->setPlayingItemInfo(playingString(), m_splitter->playingList());

	emit signalNewSong(playingString());

	if(m_systemTray)
	    m_systemTray->slotPlay();
    }
    else
	slotStop();
}

420 421 422 423
////////////////////////////////////////////////////////////////////////////////
// private slot definitions
////////////////////////////////////////////////////////////////////////////////

424
void JuK::slotPlaylistChanged()
425
{
426 427 428 429 430
    if(m_splitter->collectionListSelected()) {
	m_savePlaylistAction->setEnabled(false);
	m_saveAsPlaylistAction->setEnabled(false);
	m_renamePlaylistAction->setEnabled(false);
	m_deleteItemPlaylistAction->setEnabled(false);	
431 432
    }
    else {
433 434 435 436
	m_savePlaylistAction->setEnabled(true);
	m_saveAsPlaylistAction->setEnabled(true);
	m_renamePlaylistAction->setEnabled(true);
	m_deleteItemPlaylistAction->setEnabled(true);
437
    }
438 439 440 441

    updatePlaylistInfo();
}

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
////////////////////////////////////////////////////////////////////////////////
// edit menu
////////////////////////////////////////////////////////////////////////////////

void JuK::cut()
{
    invokeEditSlot("cut()", SLOT(cut()));
}

void JuK::copy()
{
    invokeEditSlot("copy()", SLOT(copy()));
}

void JuK::paste()
{
    invokeEditSlot("paste()", SLOT(paste()));
}

void JuK::clear()
{
    invokeEditSlot("clear()", SLOT(clear()));
}

void JuK::selectAll()
{
    invokeEditSlot("selectAll()", SLOT(selectAll()));
}

471
////////////////////////////////////////////////////////////////////////////////
472
// player menu
473 474
////////////////////////////////////////////////////////////////////////////////

475
void JuK::slotPlay()
476
{
477
    if(!m_player)
478 479
	return;

480 481
    if(m_player->paused()) {
        m_player->play();
482

483
	// Here, before doing anything, we want to make sure that the m_player did
484 485
	// in fact start.

486 487 488
        if(m_player->playing()) {
            m_pauseAction->setEnabled(true);
            m_stopAction->setEnabled(true);
489
            m_playTimer->start(m_pollInterval);
490 491
	    if(m_systemTray)
		m_systemTray->slotPlay();
492 493
        }
    }
494 495
    else if(m_player->playing())
	m_player->seekPosition(0);
496
    else
497
	play(m_splitter->playNextFile(m_randomPlayAction->isChecked()));
498 499
}

500
void JuK::slotPause()
501
{
502
    if(!m_player)
503 504
	return;

505 506 507 508 509
    m_playTimer->stop();
    m_player->pause();
    m_pauseAction->setEnabled(false);
    if(m_systemTray)
	m_systemTray->slotPause();
510 511
}

512
void JuK::slotStop()
513
{
514
    if(!m_player)
515 516
	return;

517 518
    m_playTimer->stop();
    m_player->stop();
519

520 521 522 523
    m_pauseAction->setEnabled(false);
    m_stopAction->setEnabled(false);
    m_backAction->setEnabled(false);
    m_forwardAction->setEnabled(false);
524

525 526
    m_sliderAction->getTrackPositionSlider()->setValue(0);
    m_sliderAction->getTrackPositionSlider()->setEnabled(false);
527

528
    m_splitter->stop();
529

530
    m_statusLabel->clear();
531
    
532 533
    if(m_systemTray)
	m_systemTray->slotStop();
534 535
}

536
void JuK::slotBack()
537
{
538
    play(m_splitter->playPreviousFile(m_randomPlayAction->isChecked()));
539 540
}

541
void JuK::slotForward()
542
{
543
    play(m_splitter->playNextFile(m_randomPlayAction->isChecked()));
544 545
}

546 547 548 549
////////////////////////////////////////////////////////////////////////////////
// settings menu
////////////////////////////////////////////////////////////////////////////////

550
void JuK::slotShowGenreListEditor()
551 552 553 554
{
    GenreListEditor * editor = new GenreListEditor();
    editor->exec();
}
555

556
void JuK::slotToggleSystemTray(bool enabled)
557
{
558
    if(enabled && !m_systemTray)
559
	setupSystemTray();
560 561 562
    else if(!enabled && m_systemTray) {
	delete m_systemTray;
	m_systemTray = 0;
563
	m_toggleDockOnCloseAction->setEnabled(false);
564 565 566
    }
}

567
void JuK::slotSetOutput(int output)
568
{
569
    slotStop();
570 571
    delete m_player;
    m_player = Player::createPlayer(output);
572 573
}

574
////////////////////////////////////////////////////////////////////////////////
575
// additional player slots
576 577
////////////////////////////////////////////////////////////////////////////////

578
void JuK::slotTrackPositionSliderClicked()
579
{
580
    m_trackPositionDragging = true;
581 582
}

583
void JuK::slotTrackPositionSliderReleased()
584
{
585
    if(!m_player)
586 587
	return;

588 589
    m_trackPositionDragging = false;
    m_player->seekPosition(m_sliderAction->getTrackPositionSlider()->value());
590 591
}

592
void JuK::slotTrackPositionSliderUpdate(int position)
593
{
594
    if(!m_player)
595 596
	return;

597 598
    if(m_player->playing() && !m_trackPositionDragging && !m_noSeek)
        m_player->seekPosition(position);
599 600
}

601 602
// This method is called when the play timer has expired.

603
void JuK::slotPollPlay()
604
{
605
    if(!m_player)
606 607
	return;

608 609
    // Our locking mechanism.  Since this method adjusts the play slider, we 
    // want to make sure that our adjustments
610
    m_noSeek = true;
611

612
    if(!m_player->playing()) {
613

614
        m_playTimer->stop();
615

616 617
	if(!m_player->paused())
	    play(m_splitter->playNextFile(m_randomPlayAction->isChecked()));
618

619
    }
620 621 622 623
    else if(!m_trackPositionDragging) {
        m_sliderAction->getTrackPositionSlider()->setValue(m_player->position());
	m_statusLabel->setItemTotalTime(m_player->totalTime());
	m_statusLabel->setItemCurrentTime(m_player->currentTime());
624 625 626 627 628 629
    }

    // Ok, this is weird stuff, but it works pretty well.  Ordinarily we don't
    // need to check up on our playing time very often, but in the span of the 
    // last interval, we want to check a lot -- to figure out that we've hit the
    // end of the song as soon as possible.
630

631
    if(m_player->playing() && m_player->totalTime() > 0 && float(m_player->totalTime() - m_player->currentTime()) < m_pollInterval * 2)
632
        m_playTimer->changeInterval(50);
633

634
    m_noSeek = false;
635 636
}

637
void JuK::slotSetVolume(int volume)
638
{
639 640 641
    if(m_player && m_sliderAction && m_sliderAction->getVolumeSlider() &&
       m_sliderAction->getVolumeSlider()->maxValue() > 0 &&
       volume >= 0 && m_sliderAction->getVolumeSlider()->maxValue() >= volume)
642
    {
643
        m_player->setVolume(float(volume) / float(m_sliderAction->getVolumeSlider()->maxValue()));
644 645
    }
}
646

647
#include "juk.moc"