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