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()
 135 {
 136         Timer = boost::posix_time::microsec_clock::local_time();
 137         if (Mpd.Connected())
 138         {
 139                 if (State::player() == MPD::psPlay
 140                 &&  Global::Timer - past > boost::posix_time::seconds(1))
 141                 {
 142                         // update elapsed time/bitrate of the current song
 143                         Status::Changes::elapsedTime(true);
 144                         wFooter->refresh();
 145                         past = Timer;
 146                 }
 147
 148                 applyToVisibleWindows(&BaseScreen::update);
 149                 Statusbar::tryRedraw();
 150
 151                 Mpd.idle();
 152         }
 153 }
 154
 155 void Status::update(int event)
 156 {
 157         MPD::Status old_status = m_status;
 158         m_status = Mpd.getStatus();
 159         m_player_state = m_status.playerState();
 160         m_volume = m_status.volume();
 161         myPlaylist->setStatus(m_status);
 162
 163         if (event & MPD_IDLE_DATABASE)
 164                 Changes::database();
 165         if (event & MPD_IDLE_STORED_PLAYLIST)
 166                 Changes::storedPlaylists();
 167         if (event & MPD_IDLE_PLAYLIST)
 168                 Changes::playlist();
 169         if (event & MPD_IDLE_PLAYER)
 170         {
 171                 Changes::playerState();
 172                 if (old_status.empty() || old_status.currentSongID() != m_status.currentSongID())
 173                         Changes::songID();
 174         }
 175         if (event & MPD_IDLE_MIXER)
 176                 Changes::mixer();
 177         if (event & MPD_IDLE_OUTPUT)
 178                 Changes::outputs();
 179         if (event & (MPD_IDLE_UPDATE | MPD_IDLE_OPTIONS))
 180         {
 181                 if (event & MPD_IDLE_UPDATE)
 182                         Changes::dbUpdateState(!old_status.empty());
 183                 if (event & MPD_IDLE_OPTIONS)
 184                 {
 185                         if (old_status.empty() || old_status.repeat() != m_status.repeat())
 186                                 Changes::repeat(!old_status.empty());
 187                         if (old_status.empty() || old_status.random() != m_status.random())
 188                                 Changes::random(!old_status.empty());
 189                         if (old_status.empty() || old_status.single() != m_status.single())
 190                                 Changes::single(!old_status.empty());
 191                         if (old_status.empty() || old_status.consume() != m_status.consume())
 192                                 Changes::consume(!old_status.empty());
 193                         if (old_status.empty() || old_status.crossfade() != m_status.crossfade())
 194                                 Changes::crossfade(!old_status.empty());
 195                 }
 196                 Changes::flags();
 197         }
 198
 199         if (event & MPD_IDLE_PLAYER)
 200                 wFooter->refresh();
 201
 202         if (event & (MPD_IDLE_PLAYLIST | MPD_IDLE_DATABASE | MPD_IDLE_PLAYER))
 203                 applyToVisibleWindows(&BaseScreen::refreshWindow);
 204 }
 205
 206 /*************************************************************************/
 207
 208 bool Status::State::repeat()
 209 {
 210         return m_repeat;
 211 }
 212
 213 bool Status::State::random()
 214 {
 215         return m_random;
 216 }
 217
 218 bool Status::State::single()
 219 {
 220         return m_single;
 221 }
 222
 223 bool Status::State::consume()
 224 {
 225         return m_consume;
 226 }
 227
 228 bool Status::State::crossfade()
 229 {
 230         return m_crossfade;
 231 }
 232
 233 MPD::PlayerState Status::State::player()
 234 {
 235         return m_player_state;
 236 }
 237
 238 int Status::State::volume()
 239 {
 240         return m_volume;
 241 }
 242
 243 unsigned int Status::State::elapsedTime()
 244 {
 245         return m_elapsed_time;
 246 }
 247
 248 /*************************************************************************/
 249
 250 void Status::Changes::playlist()
 251 {
 252         myPlaylist->main().clearSearchResults();
 253         withUnfilteredMenuReapplyFilter(myPlaylist->main(), []() {
 254                 size_t playlist_length = m_status.playlistLength();
 255                 if (playlist_length < myPlaylist->main().size())
 256                 {
 257                         auto it = myPlaylist->main().begin()+playlist_length;
 258                         auto end = myPlaylist->main().end();
 259                         for (; it != end; ++it)
 260                                 myPlaylist->unregisterSong(it->value());
 261                         myPlaylist->main().resizeList(playlist_length);
 262                 }
 263
 264                 Mpd.GetPlaylistChanges(myPlaylist->oldVersion(), [](MPD::Song s) {
 265                         size_t pos = s.getPosition();
 266                         if (pos < myPlaylist->main().size())
 267                         {
 268                                 // if song's already in playlist, replace it with a new one
 269                                 MPD::Song &old_s = myPlaylist->main()[pos].value();
 270                                 myPlaylist->unregisterSong(old_s);
 271                                 old_s = s;
 272                         }
 273                         else // otherwise just add it to playlist
 274                                 myPlaylist->main().addItem(s);
 275                         myPlaylist->registerSong(s);
 276                 });
 277         });
 278
 279         if (State::player() != MPD::psStop)
 280                 drawTitle(myPlaylist->nowPlayingSong());
 281
 282         myPlaylist->reloadTotalLength();
 283         myPlaylist->reloadRemaining();
 284
 285         if (isVisible(myBrowser))
 286                 markSongsInPlaylist(myBrowser->proxySongList());
 287         if (isVisible(mySearcher))
 288                 markSongsInPlaylist(mySearcher->proxySongList());
 289         if (isVisible(myLibrary))
 290         {
 291                 markSongsInPlaylist(myLibrary->songsProxyList());
 292                 myLibrary->Songs.refresh();
 293         }
 294         if (isVisible(myPlaylistEditor))
 295         {
 296                 markSongsInPlaylist(myPlaylistEditor->contentProxyList());
 297                 myPlaylistEditor->Content.refresh();
 298         }
 299 }
 300
 301 void Status::Changes::storedPlaylists()
 302 {
 303         myPlaylistEditor->requestPlaylistsUpdate();
 304         myPlaylistEditor->requestContentsUpdate();
 305         if (myBrowser->CurrentDir() == "/")
 306         {
 307                 myBrowser->GetDirectory("/");
 308                 if (isVisible(myBrowser))
 309                         myBrowser->refresh();
 310         }
 311 }
 312
 313 void Status::Changes::database()
 314 {
 315         if (isVisible(myBrowser))
 316                 myBrowser->GetDirectory(myBrowser->CurrentDir());
 317         else
 318                 myBrowser->main().clear();
 319 #       ifdef HAVE_TAGLIB_H
 320         myTagEditor->Dirs->clear();
 321 #       endif // HAVE_TAGLIB_H
 322         myLibrary->requestTagsUpdate();
 323         myLibrary->requestAlbumsUpdate();
 324         myLibrary->requestSongsUpdate();
 325 }
 326
 327 void Status::Changes::playerState()
 328 {
 329         switch (State::player())
 330         {
 331                 case MPD::psPlay:
 332                         drawTitle(myPlaylist->nowPlayingSong());
 333                         myPlaylist->reloadRemaining();
 334                         break;
 335                 case MPD::psStop:
 336                         windowTitle("ncmpcpp " VERSION);
 337                         if (Progressbar::isUnlocked())
 338                                 Progressbar::draw(0, 0);
 339                         myPlaylist->reloadRemaining();
 340                         if (Config.design == Design::Alternative)
 341                         {
 342                                 *wHeader << NC::XY(0, 0) << wclrtoeol << NC::XY(0, 1) << wclrtoeol;
 343                                 mixer();
 344                                 flags();
 345                         }
 346 #                       ifdef ENABLE_VISUALIZER
 347                         if (isVisible(myVisualizer))
 348                                 myVisualizer->main().clear();
 349 #                       endif // ENABLE_VISUALIZER
 350                         break;
 351                 default:
 352                         break;
 353         }
 354
 355         std::string state = playerStateToString(State::player());
 356         if (Config.design == Design::Alternative)
 357         {
 358                 *wHeader << NC::XY(0, 1) << NC::Format::Bold << state << NC::Format::NoBold;
 359                 wHeader->refresh();
 360         }
 361         else if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 362         {
 363                 *wFooter << NC::XY(0, 1);
 364                 if (state.empty())
 365                         *wFooter << wclrtoeol;
 366                 else
 367                         *wFooter << NC::Format::Bold << state << NC::Format::NoBold;
 368         }
 369
 370         // needed for immediate display after starting
 371         // player from stopped state or seeking
 372         elapsedTime(false);
 373 }
 374
 375 void Status::Changes::songID()
 376 {
 377         // update information about current song
 378         myPlaylist->setStatus(m_status);
 379         myPlaylist->reloadRemaining();
 380         playing_song_scroll_begin = 0;
 381         first_line_scroll_begin = 0;
 382         second_line_scroll_begin = 0;
 383         if (State::player() != MPD::psStop)
 384         {
 385                 GNUC_UNUSED int res;
 386                 if (!Config.execute_on_song_change.empty())
 387                         res = system(Config.execute_on_song_change.c_str());
 388
 389 #               ifdef HAVE_CURL_CURL_H
 390                 if (Config.fetch_lyrics_in_background)
 391                         Lyrics::DownloadInBackground(myPlaylist->nowPlayingSong());
 392 #               endif // HAVE_CURL_CURL_H
 393
 394                 drawTitle(myPlaylist->nowPlayingSong());
 395
 396                 if (Config.autocenter_mode && !myPlaylist->main().isFiltered())
 397                         myPlaylist->main().highlight(myPlaylist->currentSongPosition());
 398
 399                 if (Config.now_playing_lyrics && isVisible(myLyrics) && myLyrics->previousScreen() == myPlaylist)
 400                         myLyrics->ReloadNP = 1;
 401         }
 402         elapsedTime(false);
 403 }
 404
 405 void Status::Changes::elapsedTime(bool update_elapsed)
 406 {
 407         MPD::Status st = m_status;
 408         if (update_elapsed)
 409         {
 410                 st = Mpd.getStatus();
 411                 m_elapsed_time = st.elapsedTime();
 412         }
 413
 414         if (st.playerState() == MPD::psStop)
 415         {
 416                 if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 417                         *wFooter << NC::XY(0, 1) << wclrtoeol;
 418                 return;
 419         }
 420
 421         std::string ps = playerStateToString(st.playerState());
 422         MPD::Song np = myPlaylist->nowPlayingSong();
 423         drawTitle(np);
 424
 425         std::string tracklength;
 426         switch (Config.design)
 427         {
 428                 case Design::Classic:
 429                         if (Statusbar::isUnlocked() && Config.statusbar_visibility)
 430                         {
 431                                 if (Config.display_bitrate && st.kbps())
 432                                 {
 433                                         tracklength += " [";
 434                                         tracklength += boost::lexical_cast<std::string>(st.kbps());
 435                                         tracklength += " kbps]";
 436                                 }
 437                                 tracklength += " [";
 438                                 if (st.totalTime())
 439                                 {
 440                                         if (Config.display_remaining_time)
 441                                         {
 442                                                 tracklength += "-";
 443                                                 tracklength += MPD::Song::ShowTime(st.totalTime()-st.elapsedTime());
 444                                         }
 445                                         else
 446                                                 tracklength += MPD::Song::ShowTime(st.elapsedTime());
 447                                         tracklength += "/";
 448                                         tracklength += MPD::Song::ShowTime(st.totalTime());
 449                                         tracklength += "]";
 450                                 }
 451                                 else
 452                                 {
 453                                         tracklength += MPD::Song::ShowTime(st.elapsedTime());
 454                                         tracklength += "]";
 455                                 }
 456                                 NC::WBuffer np_song;
 457                                 stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.song_status_format, Config.tags_separator, "$"))), np_song);
 458                                 *wFooter << NC::XY(0, 1) << wclrtoeol << NC::Format::Bold << ps << NC::Format::NoBold;
 459                                 writeCyclicBuffer(np_song, *wFooter, playing_song_scroll_begin, wFooter->getWidth()-ps.length()-tracklength.length(), L" ** ");
 460                                 *wFooter << NC::Format::Bold << NC::XY(wFooter->getWidth()-tracklength.length(), 1) << tracklength << NC::Format::NoBold;
 461                         }
 462                         break;
 463                 case Design::Alternative:
 464                         if (Config.display_remaining_time)
 465                         {
 466                                 tracklength = "-";
 467                                 tracklength += MPD::Song::ShowTime(st.totalTime()-st.elapsedTime());
 468                         }
 469                         else
 470                                 tracklength = MPD::Song::ShowTime(st.elapsedTime());
 471                         if (st.totalTime())
 472                         {
 473                                 tracklength += "/";
 474                                 tracklength += MPD::Song::ShowTime(st.totalTime());
 475                         }
 476                         // bitrate here doesn't look good, but it can be moved somewhere else later
 477                         if (Config.display_bitrate && st.kbps())
 478                         {
 479                                 tracklength += " ";
 480                                 tracklength += boost::lexical_cast<std::string>(st.kbps());
 481                                 tracklength += " kbps";
 482                         }
 483
 484                         NC::WBuffer first, second;
 485                         stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.new_header_first_line, Config.tags_separator, "$"))), first);
 486                         stringToBuffer(ToWString(Charset::utf8ToLocale(np.toString(Config.new_header_second_line, Config.tags_separator, "$"))), second);
 487
 488                         size_t first_len = wideLength(first.str());
 489                         size_t first_margin = (std::max(tracklength.length()+1, VolumeState.length()))*2;
 490                         size_t first_start = first_len < COLS-first_margin ? (COLS-first_len)/2 : tracklength.length()+1;
 491
 492                         size_t second_len = wideLength(second.str());
 493                         size_t second_margin = (std::max(ps.length(), size_t(8))+1)*2;
 494                         size_t second_start = second_len < COLS-second_margin ? (COLS-second_len)/2 : ps.length()+1;
 495
 496                         if (!Global::SeekingInProgress)
 497                                 *wHeader << NC::XY(0, 0) << wclrtoeol << tracklength;
 498                         *wHeader << NC::XY(first_start, 0);
 499                         writeCyclicBuffer(first, *wHeader, first_line_scroll_begin, COLS-tracklength.length()-VolumeState.length()-1, L" ** ");
 500
 501                         *wHeader << NC::XY(0, 1) << wclrtoeol << NC::Format::Bold << ps << NC::Format::NoBold;
 502                         *wHeader << NC::XY(second_start, 1);
 503                         writeCyclicBuffer(second, *wHeader, second_line_scroll_begin, COLS-ps.length()-8-2, L" ** ");
 504
 505                         *wHeader << NC::XY(wHeader->getWidth()-VolumeState.length(), 0) << Config.volume_color << VolumeState << NC::Color::End;
 506
 507                         flags();
 508         }
 509         if (Progressbar::isUnlocked())
 510                 Progressbar::draw(st.elapsedTime(), st.totalTime());
 511 }
 512
 513 void Status::Changes::repeat(bool show_msg)
 514 {
 515         m_repeat = m_status.repeat() ? 'r' : 0;
 516         if (show_msg)
 517                 Statusbar::printf("Repeat mode is %1%", !m_repeat ? "off" : "on");
 518 }
 519
 520 void Status::Changes::random(bool show_msg)
 521 {
 522         m_random = m_status.random() ? 'z' : 0;
 523         if (show_msg)
 524                 Statusbar::printf("Random mode is %1%", !m_random ? "off" : "on");
 525 }
 526
 527 void Status::Changes::single(bool show_msg)
 528 {
 529         m_single = m_status.single() ? 's' : 0;
 530         if (show_msg)
 531                 Statusbar::printf("Single mode is %1%", !m_single ? "off" : "on");
 532 }
 533
 534 void Status::Changes::consume(bool show_msg)
 535 {
 536         m_consume = m_status.consume() ? 'c' : 0;
 537         if (show_msg)
 538                 Statusbar::printf("Consume mode is %1%", !m_consume ? "off" : "on");
 539 }
 540
 541 void Status::Changes::crossfade(bool show_msg)
 542 {
 543         int crossfade = m_status.crossfade();
 544         m_crossfade = crossfade ? 'x' : 0;
 545         if (show_msg)
 546                 Statusbar::printf("Crossfade set to %1% seconds", crossfade);
 547 }
 548
 549 void Status::Changes::dbUpdateState(bool show_msg)
 550 {
 551         m_db_updating = m_status.updateID() ? 'U' : 0;
 552         if (show_msg)
 553                 Statusbar::printf("Database update %1%", m_status.updateID() ? "started" : "finished");
 554 }
 555
 556 void Status::Changes::flags()
 557 {
 558         if (!Config.header_visibility && Config.design == Design::Classic)
 559                 return;
 560
 561         std::string switch_state;
 562         switch (Config.design)
 563         {
 564                 case Design::Classic:
 565                         if (m_repeat)
 566                                 switch_state += m_repeat;
 567                         if (m_random)
 568                                 switch_state += m_random;
 569                         if (m_single)
 570                                 switch_state += m_single;
 571                         if (m_consume)
 572                                 switch_state += m_consume;
 573                         if (m_crossfade)
 574                                 switch_state += m_crossfade;
 575                         if (m_db_updating)
 576                                 switch_state += m_db_updating;
 577
 578                         // this is done by raw ncurses because creating another
 579                         // window only for handling this is quite silly
 580                         attrset(A_BOLD|COLOR_PAIR(int(Config.state_line_color)));
 581                         mvhline(1, 0, 0, COLS);
 582                         if (!switch_state.empty())
 583                         {
 584                                 mvprintw(1, COLS-switch_state.length()-3, "[");
 585                                 attroff(COLOR_PAIR(int(Config.state_line_color)));
 586                                 attron(COLOR_PAIR(int(Config.state_flags_color)));
 587                                 mvprintw(1, COLS-switch_state.length()-2, "%s", switch_state.c_str());
 588                                 attroff(COLOR_PAIR(int(Config.state_flags_color)));
 589                                 attron(COLOR_PAIR(int(Config.state_line_color)));
 590                                 mvprintw(1, COLS-2, "]");
 591                         }
 592                         attrset(COLOR_PAIR(int(Config.main_color)));
 593                         refresh();
 594                         break;
 595                 case Design::Alternative:
 596                         switch_state += '[';
 597                         switch_state += m_repeat ? m_repeat : '-';
 598                         switch_state += m_random ? m_random : '-';
 599                         switch_state += m_single ? m_single : '-';
 600                         switch_state += m_consume ? m_consume : '-';
 601                         switch_state += m_crossfade ? m_crossfade : '-';
 602                         switch_state += m_db_updating ? m_db_updating : '-';
 603                         switch_state += ']';
 604                         *wHeader << NC::XY(COLS-switch_state.length(), 1) << NC::Format::Bold << Config.state_flags_color << switch_state << NC::Color::End << NC::Format::NoBold;
 605                         if (!Config.header_visibility) // in this case also draw separator
 606                         {
 607                                 *wHeader << NC::Format::Bold << NC::Color::Black;
 608                                 mvwhline(wHeader->raw(), 2, 0, 0, COLS);
 609                                 *wHeader << NC::Color::End << NC::Format::NoBold;
 610                         }
 611                         wHeader->refresh();
 612                         break;
 613         }
 614 }
 615
 616 void Status::Changes::mixer()
 617 {
 618         if (!Config.display_volume_level || (!Config.header_visibility && Config.design == Design::Classic))
 619                 return;
 620
 621         switch (Config.design)
 622         {
 623                 case Design::Classic:
 624                         VolumeState = " " "Volume" ": ";
 625                         break;
 626                 case Design::Alternative:
 627                         VolumeState = " " "Vol" ": ";
 628                         break;
 629         }
 630         if (State::volume() < 0)
 631                 VolumeState += "n/a";
 632         else
 633         {
 634                 VolumeState += boost::lexical_cast<std::string>(State::volume());
 635                 VolumeState += "%";
 636         }
 637         *wHeader << Config.volume_color;
 638         *wHeader << NC::XY(wHeader->getWidth()-VolumeState.length(), 0) << VolumeState;
 639         *wHeader << NC::Color::End;
 640         wHeader->refresh();
 641 }
 642
 643 void Status::Changes::outputs()
 644 {
 645 #       ifdef ENABLE_OUTPUTS
 646         myOutputs->FetchList();
 647 #       endif // ENABLE_OUTPUTS
 648 }