src/status.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2014 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include "browser.h"
  22 #include "charset.h"
  23 #include "global.h"
  24 #include "helpers.h"
  25 #include "lyrics.h"
  26 #include "media_library.h"
  27 #include "outputs.h"
  28 #include "playlist.h"
  29 #include "playlist_editor.h"
  30 #include "search_engine.h"
  31 #include "sel_items_adder.h"
  32 #include "settings.h"
  33 #include "status.h"
  34 #include "statusbar.h"
  35 #include "tag_editor.h"
  36 #include "visualizer.h"
  37 #include "title.h"
  38 #include "utility/string.h"
  39
  40 using Global::myScreen;
  41
  42 using Global::wFooter;
  43 using Global::wHeader;
  44
  45 using Global::Timer;
  46 using Global::VolumeState;
  47
  48 namespace {//
  49
  50 boost::posix_time::ptime past = boost::posix_time::from_time_t(0);
  51
  52 size_t playing_song_scroll_begin = 0;
  53 size_t first_line_scroll_begin = 0;
  54 size_t second_line_scroll_begin = 0;
  55
  56 char m_repeat = 0;
  57 char m_random = 0;
  58 char m_single = 0;
  59 char m_consume = 0;
  60 char m_crossfade = 0;
  61 char m_db_updating = 0;
  62
  63 MPD::Status m_status;
  64 MPD::PlayerState m_player_state = MPD::psUnknown;
  65 int m_volume = -1;
  66 unsigned m_elapsed_time = 0;
  67
  68 void drawTitle(const MPD::Song &np)
  69 {
  70         assert(!np.empty());
  71         windowTitle(np.toString(Config.song_window_title_format, Config.tags_separator));
  72 }
  73
  74 std::string playerStateToString(MPD::PlayerState ps)
  75 {
  76         std::string result;
  77         switch (ps)
  78         {
  79                 case MPD::psUnknown:
  80                         result = "[unknown]";
  81                         break;
  82                 case MPD::psPlay:
  83                         if (Config.design == Design::Alternative)
  84                                 result = "[playing]";
  85                         else
  86                                 result = "Playing: ";
  87                         break;
  88                 case MPD::psPause:
  89                         if (Config.design == Design::Alternative)
  90                                 result = "[paused] ";
  91                         else
  92                                 result = "[Paused] ";
  93                         break;
  94                 case MPD::psStop:
  95                         if (Config.design == Design::Alternative)
  96                                 result = "[stopped]";
  97                         break;
  98                 default:
  99                         break;
 100         }
 101         return result;
 102 }
 103
 104 }
 105
 106 void Status::handleClientError(MPD::ClientError &e)
 107 {
 108         if (!e.clearable())
 109                 Mpd.Disconnect();
 110         Statusbar::printf("ncmpcpp: %1%", e.what());
 111 }
 112
 113 void Status::handleServerError(MPD::ServerError &e)
 114 {
 115         if (e.code() == MPD_SERVER_ERROR_PERMISSION)
 116         {
 117                 wFooter->setGetStringHelper(nullptr);
 118                 Statusbar::put() << "Password: ";
 119                 Mpd.SetPassword(wFooter->getString(0, true));
 120                 Mpd.SendPassword();
 121                 Statusbar::print("Password accepted");
 122                 wFooter->setGetStringHelper(Statusbar::Helpers::getString);
 123         }
 124         else if (e.code() == MPD_SERVER_ERROR_NO_EXIST && myScreen == myBrowser)
 125         {
 126                 myBrowser->GetDirectory(getParentDirectory(myBrowser->CurrentDir()));
 127                 myBrowser->refresh();
 128         }
 129         Statusbar::printf("MPD: %1%", e.what());
 130 }
 131
 132 /*************************************************************************/
 133
 134 void Status::trace(bool update_timer, bool update_window_timeout)
 135 {
 136         if (update_timer)
 137                 Timer = boost::posix_time::microsec_clock::local_time();
 138         if (Mpd.Connected())
 139         {
 140                 if (State::player() == MPD::psPlay
 141                 &&  Global::Timer - past > boost::posix_time::seconds(1))
 142                 {
 143                         // update elapsed time/bitrate of the current song
 144                         Status::Changes::elapsedTime(true);
 145                         wFooter->refresh();
 146                         past = Timer;
 147                 }
 148
 149                 applyToVisibleWindows(&BaseScreen::update);
 150                 Statusbar::tryRedraw();
 151
 152                 if (update_window_timeout)
 153                 {
 154                         // set appropriate window timeout
 155                         int nc_wtimeout = std::numeric_limits<int>::max();
 156                         applyToVisibleWindows([&nc_wtimeout](BaseScreen *s) {
 157                                 nc_wtimeout = std::min(nc_wtimeout, s->windowTimeout());
 158                         });
 159                         wFooter->setTimeout(nc_wtimeout);
 160                 }
 161
 162                 Mpd.idle();
 163         }
 164 }
 165
 166 void Status::update(int event)
 167 {
 168         MPD::Status old_status = m_status;
 169         m_status = Mpd.getStatus();
 170         m_player_state = m_status.playerState();
 171         m_volume = m_status.volume();
 172         myPlaylist->setStatus(m_status);
 173
 174         if (event & MPD_IDLE_DATABASE)
 175                 Changes::database();
 176         if (event & MPD_IDLE_STORED_PLAYLIST)
 177                 Changes::storedPlaylists();
 178         if (event & MPD_IDLE_PLAYLIST)
 179                 Changes::playlist();
 180         if (event & MPD_IDLE_PLAYER)
 181         {
 182                 Changes::playerState();
 183                 if (old_status.empty() || old_status.currentSongID() != m_status.currentSongID())
 184                         Changes::songID();
 185         }
 186         if (event & MPD_IDLE_MIXER)
 187                 Changes::mixer();
 188         if (event & MPD_IDLE_OUTPUT)
 189                 Changes::outputs();
 190         if (event & (MPD_IDLE_UPDATE | MPD_IDLE_OPTIONS))
 191         {
 192                 if (event & MPD_IDLE_UPDATE)
 193                         Changes::dbUpdateState(!old_status.empty());
 194                 if (event & MPD_IDLE_OPTIONS)
 195                 {
 196                         if (old_status.empty() || old_status.repeat() != m_status.repeat())
 197                                 Changes::repeat(!old_status.empty());
 198                         if (old_status.empty() || old_status.random() != m_status.random())
 199                                 Changes::random(!old_status.empty());
 200                         if (old_status.empty() || old_status.single() != m_status.single())
 201                                 Changes::single(!old_status.empty());
 202                         if (old_status.empty() || old_status.consume() != m_status.consume())
 203                                 Changes::consume(!old_status.empty());
 204                         if (old_status.empty() || old_status.crossfade() != m_status.crossfade())
 205                                 Changes::crossfade(!old_status.empty());
 206                 }
 207                 Changes::flags();
 208         }
 209
 210         if (event & MPD_IDLE_PLAYER)
 211                 wFooter->refresh();
 212
 213         if (event & (MPD_IDLE_PLAYLIST | MPD_IDLE_DATABASE | MPD_IDLE_PLAYER))
 214                 applyToVisibleWindows(&BaseScreen::refreshWindow);
 215 }
 216
 217 /*************************************************************************/
 218
 219 bool Status::State::repeat()
 220 {
 221         return m_repeat;
 222 }
 223
 224 bool Status::State::random()
 225 {
 226         return m_random;
 227 }
 228
 229 bool Status::State::single()
 230 {
 231         return m_single;
 232 }
 233
 234 bool Status::State::consume()
 235 {
 236         return m_consume;
 237 }
 238
 239 bool Status::State::crossfade()
 240 {
 241         return m_crossfade;
 242 }
 243
 244 MPD::PlayerState Status::State::player()
 245 {
 246         return m_player_state;
 247 }
 248
 249 int Status::State::volume()
 250 {
 251         return m_volume;
 252 }
 253
 254 unsigned int Status::State::elapsedTime()
 255 {
 256         return m_elapsed_time;
 257 }
 258
 259 /*************************************************************************/
 260
 261 void Status::Changes::playlist()
 262 {
 263         myPlaylist->main().clearSearchResults();
 264         withUnfilteredMenuReapplyFilter(myPlaylist->main(), []() {
 265                 size_t playlist_length = m_status.playlistLength();
 266                 if (playlist_length < myPlaylist->main().size())
 267                 {
 268                         auto it = myPlaylist->main().begin()+playlist_length;
 269                         auto end = myPlaylist->main().end();
 270                         for (; it != end; ++it)
 271                                 myPlaylist->unregisterSong(it->value());
 272                         myPlaylist->main().resizeList(playlist_length);
 273                 }
 274
 275                 Mpd.GetPlaylistChanges(myPlaylist->oldVersion(), [](MPD::Song s) {
 276                         size_t pos = s.getPosition();
 277                         if (pos < myPlaylist->main().size())
 278                         {
 279                                 // if song's already in playlist, replace it with a new one
 280                                 MPD::Song &old_s = myPlaylist->main()[pos].value();
 281                                 myPlaylist->unregisterSong(old_s);
 282                                 old_s = s;
 283                         }
 284                         else // otherwise just add it to playlist
 285                                 myPlaylist->main().addItem(s);
 286                         myPlaylist->registerSong(s);
 287                 });
 288         });
 289
 290         if (State::player() != MPD::psStop)
 291                 drawTitle(myPlaylist->nowPlayingSong());
 292
 293         myPlaylist->reloadTotalLength();
 294         myPlaylist->reloadRemaining();
 295
 296         if (isVisible(myBrowser))
 297                 markSongsInPlaylist(myBrowser->proxySongList());
 298         if (isVisible(mySearcher))
 299                 markSongsInPlaylist(mySearcher->proxySongList());
 300         if (isVisible(myLibrary))
 301         {
 302                 markSongsInPlaylist(myLibrary->songsProxyList());
 303                 myLibrary->Songs.refresh();
 304         }
 305         if (isVisible(myPlaylistEditor))
 306         {
 307                 markSongsInPlaylist(myPlaylistEditor->contentProxyList());
 308                 myPlaylistEditor->Content.refresh();
 309         }
 310 }
 311
 312 void Status::Changes::storedPlaylists()
 313 {
 314         myPlaylistEditor->requestPlaylistsUpdate();
 315         myPlaylistEditor->requestContentsUpdate();
 316         if (myBrowser->CurrentDir() == "/")
 317         {
 318                 myBrowser->GetDirectory("/");
 319                 if (isVisible(myBrowser))
 320                         myBrowser->refresh();
 321         }
 322 }
 323
 324 void Status::Changes::database()
 325 {
 326         if (isVisible(myBrowser))
 327                 myBrowser->GetDirectory(myBrowser->CurrentDir());
 328         else
 329                 myBrowser->main().clear();
 330 #       ifdef HAVE_TAGLIB_H
 331         myTagEditor->Dirs->clear();
 332 #       endif // HAVE_TAGLIB_H
 333         myLibrary->requestTagsUpdate();
 334         myLibrary->requestAlbumsUpdate();
 335         myLibrary->requestSongsUpdate();
 336 }
 337
 338 void Status::Changes::playerState()
 339 {
 340         switch (State::player())
 341         {
 342                 case MPD::psPlay:
 343                         drawTitle(myPlaylist->nowPlayingSong());
 344                         myPlaylist->reloadRemaining();
 345                         break;
 346                 case MPD::psStop:
 347                         windowTitle("ncmpcpp " VERSION);
 348                         if (Progressbar::isUnlocked())
 349                                 Progressbar::draw(0, 0);
 350                         myPlaylist->reloadRemaining();
 351                         if (Config.design == Design::Alternative)
 352                         {
 353                                 *wHeader << NC::XY(0, 0) << wclrtoeol << NC::XY(0, 1) << wclrtoeol;
 354                                 mixer();
 355                                 flags();
 356                         }
 357 #                       ifdef ENABLE_VISUALIZER
 358                         if (isVisible(myVisualizer))
 359                                 myVisualizer->main().clear();
 360 #                       endif // ENABLE_VISUALIZER
 361                         break;
 362                 default:
 363                         break;
 364         }
 365
 366         std::string state = playerStateToString(State::player());
 367         if (Config.design == Design::Alternative)
 368         {
 369                 *wHeader << NC::XY(0, 1) << NC::Format::Bold << state << NC::Format::NoBold;
 370                 wHeader->refresh();
 371         }
 372         else if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 373         {
 374                 *wFooter << NC::XY(0, 1);
 375                 if (state.empty())
 376                         *wFooter << wclrtoeol;
 377                 else
 378                         *wFooter << NC::Format::Bold << state << NC::Format::NoBold;
 379         }
 380
 381         // needed for immediate display after starting
 382         // player from stopped state or seeking
 383         elapsedTime(false);
 384 }
 385
 386 void Status::Changes::songID()
 387 {
 388         // update information about current song
 389         myPlaylist->setStatus(m_status);
 390         myPlaylist->reloadRemaining();
 391         playing_song_scroll_begin = 0;
 392         first_line_scroll_begin = 0;
 393         second_line_scroll_begin = 0;
 394         if (State::player() != MPD::psStop)
 395         {
 396                 GNUC_UNUSED int res;
 397                 if (!Config.execute_on_song_change.empty())
 398                         res = system(Config.execute_on_song_change.c_str());
 399
 400 #               ifdef HAVE_CURL_CURL_H
 401                 if (Config.fetch_lyrics_in_background)
 402                         Lyrics::DownloadInBackground(myPlaylist->nowPlayingSong());
 403 #               endif // HAVE_CURL_CURL_H
 404
 405                 drawTitle(myPlaylist->nowPlayingSong());
 406
 407                 if (Config.autocenter_mode && !myPlaylist->main().isFiltered())
 408                         myPlaylist->main().highlight(myPlaylist->currentSongPosition());
 409
 410                 if (Config.now_playing_lyrics && isVisible(myLyrics) && myLyrics->previousScreen() == myPlaylist)
 411                         myLyrics->ReloadNP = 1;
 412         }
 413         elapsedTime(false);
 414 }
 415
 416 void Status::Changes::elapsedTime(bool update_elapsed)
 417 {
 418         if (update_elapsed)
 419         {
 420                 m_status = Mpd.getStatus();
 421                 m_elapsed_time = m_status.elapsedTime();
 422         }
 423         const auto &st = m_status;
 424
 425         if (st.playerState() == MPD::psStop)
 426         {
 427                 if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 428                         *wFooter << NC::XY(0, 1) << wclrtoeol;
 429                 return;
 430         }
 431
 432         std::string ps = playerStateToString(st.playerState());
 433         MPD::Song np = myPlaylist->nowPlayingSong();
 434         drawTitle(np);
 435
 436         std::string tracklength;
 437         switch (Config.design)
 438         {
 439                 case Design::Classic:
 440                         if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 441                         {
 442                                 if (Config.display_bitrate && st.kbps())
 443                                 {
 444                                         tracklength += " [";
 445                                         tracklength += boost::lexical_cast<std::string>(st.kbps());
 446                                         tracklength += " kbps]";
 447                                 }
 448                                 tracklength += " [";
 449                                 if (st.totalTime())
 450                                 {
 451                                         if (Config.display_remaining_time)
 452                                         {
 453                                                 tracklength += "-";
 454                                                 tracklength += MPD::Song::ShowTime(st.totalTime()-st.elapsedTime());
 455                                         }
 456                                         else
 457                                                 tracklength += MPD::Song::ShowTime(st.elapsedTime());
 458                                         tracklength += "/";
 459                                         tracklength += MPD::Song::ShowTime(st.totalTime());
 460                                         tracklength += "]";
 461                                 }
 462                                 else
 463                                 {
 464                                         tracklength += MPD::Song::ShowTime(st.elapsedTime());
 465                                         tracklength += "]";
 466                                 }
 467                                 NC::WBuffer np_song;
 468                                 stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.song_status_format, Config.tags_separator, "$"))), np_song);
 469                                 *wFooter << NC::XY(0, 1) << wclrtoeol << NC::Format::Bold << ps << NC::Format::NoBold;
 470                                 writeCyclicBuffer(np_song, *wFooter, playing_song_scroll_begin, wFooter->getWidth()-ps.length()-tracklength.length(), L" ** ");
 471                                 *wFooter << NC::Format::Bold << NC::XY(wFooter->getWidth()-tracklength.length(), 1) << tracklength << NC::Format::NoBold;
 472                         }
 473                         break;
 474                 case Design::Alternative:
 475                         if (Config.display_remaining_time)
 476                         {
 477                                 tracklength = "-";
 478                                 tracklength += MPD::Song::ShowTime(st.totalTime()-st.elapsedTime());
 479                         }
 480                         else
 481                                 tracklength = MPD::Song::ShowTime(st.elapsedTime());
 482                         if (st.totalTime())
 483                         {
 484                                 tracklength += "/";
 485                                 tracklength += MPD::Song::ShowTime(st.totalTime());
 486                         }
 487                         // bitrate here doesn't look good, but it can be moved somewhere else later
 488                         if (Config.display_bitrate && st.kbps())
 489                         {
 490                                 tracklength += " ";
 491                                 tracklength += boost::lexical_cast<std::string>(st.kbps());
 492                                 tracklength += " kbps";
 493                         }
 494
 495                         NC::WBuffer first, second;
 496                         stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.new_header_first_line, Config.tags_separator, "$"))), first);
 497                         stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.new_header_second_line, Config.tags_separator, "$"))), second);
 498
 499                         size_t first_len = wideLength(first.str());
 500                         size_t first_margin = (std::max(tracklength.length()+1, VolumeState.length()))*2;
 501                         size_t first_start = first_len < COLS-first_margin ? (COLS-first_len)/2 : tracklength.length()+1;
 502
 503                         size_t second_len = wideLength(second.str());
 504                         size_t second_margin = (std::max(ps.length(), size_t(8))+1)*2;
 505                         size_t second_start = second_len < COLS-second_margin ? (COLS-second_len)/2 : ps.length()+1;
 506
 507                         if (!Global::SeekingInProgress)
 508                                 *wHeader << NC::XY(0, 0) << wclrtoeol << tracklength;
 509                         *wHeader << NC::XY(first_start, 0);
 510                         writeCyclicBuffer(first, *wHeader, first_line_scroll_begin, COLS-tracklength.length()-VolumeState.length()-1, L" ** ");
 511
 512                         *wHeader << NC::XY(0, 1) << wclrtoeol << NC::Format::Bold << ps << NC::Format::NoBold;
 513                         *wHeader << NC::XY(second_start, 1);
 514                         writeCyclicBuffer(second, *wHeader, second_line_scroll_begin, COLS-ps.length()-8-2, L" ** ");
 515
 516                         *wHeader << NC::XY(wHeader->getWidth()-VolumeState.length(), 0) << Config.volume_color << VolumeState << NC::Color::End;
 517
 518                         flags();
 519         }
 520         if (Progressbar::isUnlocked())
 521                 Progressbar::draw(st.elapsedTime(), st.totalTime());
 522 }
 523
 524 void Status::Changes::repeat(bool show_msg)
 525 {
 526         m_repeat = m_status.repeat() ? 'r' : 0;
 527         if (show_msg)
 528                 Statusbar::printf("Repeat mode is %1%", !m_repeat ? "off" : "on");
 529 }
 530
 531 void Status::Changes::random(bool show_msg)
 532 {
 533         m_random = m_status.random() ? 'z' : 0;
 534         if (show_msg)
 535                 Statusbar::printf("Random mode is %1%", !m_random ? "off" : "on");
 536 }
 537
 538 void Status::Changes::single(bool show_msg)
 539 {
 540         m_single = m_status.single() ? 's' : 0;
 541         if (show_msg)
 542                 Statusbar::printf("Single mode is %1%", !m_single ? "off" : "on");
 543 }
 544
 545 void Status::Changes::consume(bool show_msg)
 546 {
 547         m_consume = m_status.consume() ? 'c' : 0;
 548         if (show_msg)
 549                 Statusbar::printf("Consume mode is %1%", !m_consume ? "off" : "on");
 550 }
 551
 552 void Status::Changes::crossfade(bool show_msg)
 553 {
 554         int crossfade = m_status.crossfade();
 555         m_crossfade = crossfade ? 'x' : 0;
 556         if (show_msg)
 557                 Statusbar::printf("Crossfade set to %1% seconds", crossfade);
 558 }
 559
 560 void Status::Changes::dbUpdateState(bool show_msg)
 561 {
 562         m_db_updating = m_status.updateID() ? 'U' : 0;
 563         if (show_msg)
 564                 Statusbar::printf("Database update %1%", m_status.updateID() ? "started" : "finished");
 565 }
 566
 567 void Status::Changes::flags()
 568 {
 569         if (!Config.header_visibility && Config.design == Design::Classic)
 570                 return;
 571
 572         std::string switch_state;
 573         switch (Config.design)
 574         {
 575                 case Design::Classic:
 576                         if (m_repeat)
 577                                 switch_state += m_repeat;
 578                         if (m_random)
 579                                 switch_state += m_random;
 580                         if (m_single)
 581                                 switch_state += m_single;
 582                         if (m_consume)
 583                                 switch_state += m_consume;
 584                         if (m_crossfade)
 585                                 switch_state += m_crossfade;
 586                         if (m_db_updating)
 587                                 switch_state += m_db_updating;
 588
 589                         // this is done by raw ncurses because creating another
 590                         // window only for handling this is quite silly
 591                         attrset(A_BOLD|COLOR_PAIR(int(Config.state_line_color)));
 592                         mvhline(1, 0, 0, COLS);
 593                         if (!switch_state.empty())
 594                         {
 595                                 mvprintw(1, COLS-switch_state.length()-3, "[");
 596                                 attroff(COLOR_PAIR(int(Config.state_line_color)));
 597                                 attron(COLOR_PAIR(int(Config.state_flags_color)));
 598                                 mvprintw(1, COLS-switch_state.length()-2, "%s", switch_state.c_str());
 599                                 attroff(COLOR_PAIR(int(Config.state_flags_color)));
 600                                 attron(COLOR_PAIR(int(Config.state_line_color)));
 601                                 mvprintw(1, COLS-2, "]");
 602                         }
 603                         attrset(COLOR_PAIR(int(Config.main_color)));
 604                         refresh();
 605                         break;
 606                 case Design::Alternative:
 607                         switch_state += '[';
 608                         switch_state += m_repeat ? m_repeat : '-';
 609                         switch_state += m_random ? m_random : '-';
 610                         switch_state += m_single ? m_single : '-';
 611                         switch_state += m_consume ? m_consume : '-';
 612                         switch_state += m_crossfade ? m_crossfade : '-';
 613                         switch_state += m_db_updating ? m_db_updating : '-';
 614                         switch_state += ']';
 615                         *wHeader << NC::XY(COLS-switch_state.length(), 1) << NC::Format::Bold << Config.state_flags_color << switch_state << NC::Color::End << NC::Format::NoBold;
 616                         if (!Config.header_visibility) // in this case also draw separator
 617                         {
 618                                 *wHeader << NC::Format::Bold << NC::Color::Black;
 619                                 mvwhline(wHeader->raw(), 2, 0, 0, COLS);
 620                                 *wHeader << NC::Color::End << NC::Format::NoBold;
 621                         }
 622                         wHeader->refresh();
 623                         break;
 624         }
 625 }
 626
 627 void Status::Changes::mixer()
 628 {
 629         if (!Config.display_volume_level || (!Config.header_visibility && Config.design == Design::Classic))
 630                 return;
 631
 632         switch (Config.design)
 633         {
 634                 case Design::Classic:
 635                         VolumeState = " " "Volume" ": ";
 636                         break;
 637                 case Design::Alternative:
 638                         VolumeState = " " "Vol" ": ";
 639                         break;
 640         }
 641         if (State::volume() < 0)
 642                 VolumeState += "n/a";
 643         else
 644         {
 645                 VolumeState += boost::lexical_cast<std::string>(State::volume());
 646                 VolumeState += "%";
 647         }
 648         *wHeader << Config.volume_color;
 649         *wHeader << NC::XY(wHeader->getWidth()-VolumeState.length(), 0) << VolumeState;
 650         *wHeader << NC::Color::End;
 651         wHeader->refresh();
 652 }
 653
 654 void Status::Changes::outputs()
 655 {
 656 #       ifdef ENABLE_OUTPUTS
 657         myOutputs->FetchList();
 658 #       endif // ENABLE_OUTPUTS
 659 }