src/helpers.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2009 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 <cstring>
  22 #include <algorithm>
  23 #include <iostream>
  24 #include <stdexcept>
  25
  26 #include "charset.h"
  27 #include "global.h"
  28 #include "helpers.h"
  29 #include "playlist.h"
  30 #include "status.h"
  31 #include "tag_editor.h"
  32
  33 using namespace MPD;
  34
  35 bool ConnectToMPD()
  36 {
  37         if (!Mpd.Connect())
  38         {
  39                 std::cout << "Cannot connect to mpd: " << Mpd.GetErrorMessage() << std::endl;
  40                 return false;
  41         }
  42         return true;
  43 }
  44
  45 void ParseArgv(int argc, char **argv)
  46 {
  47         bool quit = 0;
  48         std::string now_playing_format = "{{(%l) }{{%a - }%t}}|{%f}}";
  49
  50         for (int i = 1; i < argc; ++i)
  51         {
  52                 if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--host"))
  53                 {
  54                         if (++i >= argc)
  55                                 exit(0);
  56                         Mpd.SetHostname(argv[i]);
  57                         continue;
  58                 }
  59                 if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--port"))
  60                 {
  61                         if (++i >= argc)
  62                                 exit(0);
  63                         Mpd.SetPort(atoi(argv[i]));
  64                         continue;
  65                 }
  66                 else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version"))
  67                 {
  68                         std::cout << "ncmpcpp version: " << VERSION << "\n\n"
  69                         << "optional screens compiled-in:\n"
  70 #                       ifdef HAVE_TAGLIB_H
  71                         << " - tag editor\n"
  72                         << " - tiny tag editor\n"
  73 #                       endif
  74 #                       ifdef HAVE_CURL_CURL_H
  75                         << " - artist info\n"
  76 #                       endif
  77 #                       ifdef ENABLE_OUTPUTS
  78                         << " - outputs\n"
  79 #                       endif
  80 #                       ifdef ENABLE_VISUALIZER
  81                         << " - visualizer\n"
  82 #                       endif
  83 #                       ifdef ENABLE_CLOCK
  84                         << " - clock\n"
  85 #                       endif
  86                         << "\nencoding detection: "
  87 #                       ifdef HAVE_LANGINFO_H
  88                         << "enabled"
  89 #                       else
  90                         << "disabled"
  91 #                       endif // HAVE_LANGINFO_H
  92                         << "\nbuilt with support for:"
  93 #                       ifdef HAVE_CURL_CURL_H
  94                         << " curl"
  95 #                       endif
  96 #                       ifdef HAVE_ICONV_H
  97                         << " iconv"
  98 #                       endif
  99 #                       ifdef HAVE_FFTW3_H
 100                         << " fftw"
 101 #                       endif
 102 #                       ifdef USE_PDCURSES
 103                         << " pdcurses"
 104 #                       else
 105                         << " ncurses"
 106 #                       endif
 107 #                       ifdef HAVE_TAGLIB_H
 108                         << " taglib"
 109 #                       endif
 110 #                       ifdef HAVE_PTHREAD_H
 111                         << " threads"
 112 #                       endif
 113 #                       ifdef _UTF8
 114                         << " unicode"
 115 #                       endif
 116                         << std::endl;
 117                         exit(0);
 118                 }
 119                 else if (!strcmp(argv[i], "-?") || !strcmp(argv[i], "--help"))
 120                 {
 121                         std::cout
 122                         << "Usage: ncmpcpp [OPTION]...\n"
 123                         << "  -h, --host                connect to server at host [localhost]\n"
 124                         << "  -p, --port                connect to server at port [6600]\n"
 125                         << "  -?, --help                show this help message\n"
 126                         << "  -v, --version             display version information\n"
 127                         << "  --now-playing             display now playing song [" << now_playing_format << "]\n"
 128                         << "\n"
 129                         << "  play                      start playing\n"
 130                         << "  pause                     pause the currently playing song\n"
 131                         << "  toggle                    toggle play/pause mode\n"
 132                         << "  stop                      stop playing\n"
 133                         << "  next                      play the next song\n"
 134                         << "  prev                      play the previous song\n"
 135                         << "  volume [+-]<num>          adjusts volume by [+-]<num>\n"
 136                         ;
 137                         exit(0);
 138                 }
 139
 140                 if (!ConnectToMPD())
 141                         exit(0);
 142
 143                 if (!strcmp(argv[i], "--now-playing"))
 144                 {
 145                         Mpd.UpdateStatus();
 146                         if (!Mpd.GetErrorMessage().empty())
 147                         {
 148                                 std::cout << "Error: " << Mpd.GetErrorMessage() << std::endl;
 149                                 exit(1);
 150                         }
 151                         if (Mpd.isPlaying())
 152                         {
 153                                 if (argc > ++i)
 154                                 {
 155                                         // apply additional pair of braces
 156                                         now_playing_format = "{";
 157                                         now_playing_format += argv[i];
 158                                         now_playing_format += "}";
 159                                         MPD::Song::ValidateFormat("now-playing format", now_playing_format);
 160                                 }
 161                                 std::cout << utf_to_locale_cpy(Mpd.GetCurrentSong().toString(now_playing_format)) << "\n";
 162                         }
 163                         exit(0);
 164                 }
 165                 else if (!strcmp(argv[i], "play"))
 166                 {
 167                         Mpd.Play();
 168                         quit = 1;
 169                 }
 170                 else if (!strcmp(argv[i], "pause"))
 171                 {
 172                         Mpd.Pause(1);
 173                         quit = 1;
 174                 }
 175                 else if (!strcmp(argv[i], "toggle"))
 176                 {
 177                         Mpd.Toggle();
 178                         quit = 1;
 179                 }
 180                 else if (!strcmp(argv[i], "stop"))
 181                 {
 182                         Mpd.Stop();
 183                         quit = 1;
 184                 }
 185                 else if (!strcmp(argv[i], "next"))
 186                 {
 187                         Mpd.Next();
 188                         quit = 1;
 189                 }
 190                 else if (!strcmp(argv[i], "prev"))
 191                 {
 192                         Mpd.Prev();
 193                         quit = 1;
 194                 }
 195                 else if (!strcmp(argv[i], "volume"))
 196                 {
 197                         i++;
 198                         Mpd.UpdateStatus();
 199                         if (!Mpd.GetErrorMessage().empty())
 200                         {
 201                                 std::cout << "Error: " << Mpd.GetErrorMessage() << std::endl;
 202                                 exit(1);
 203                         }
 204                         if (i != argc)
 205                                 Mpd.SetVolume(Mpd.GetVolume()+atoi(argv[i]));
 206                         quit = 1;
 207                 }
 208                 else
 209                 {
 210                         std::cout << "ncmpcpp: invalid option: " << argv[i] << std::endl;
 211                         exit(0);
 212                 }
 213                 if (!Mpd.GetErrorMessage().empty())
 214                 {
 215                         std::cout << "Error: " << Mpd.GetErrorMessage() << std::endl;
 216                         exit(0);
 217                 }
 218         }
 219         if (quit)
 220                 exit(0);
 221 }
 222
 223 bool CaseInsensitiveSorting::operator()(const Item &a, const Item &b)
 224 {
 225         if (a.type == b.type)
 226         {
 227                 switch (a.type)
 228                 {
 229                         case itDirectory:
 230                                 return cmp(ExtractTopDirectory(a.name), ExtractTopDirectory(b.name)) < 0;
 231                         case itPlaylist:
 232                                 return cmp(a.name, b.name) < 0;
 233                         case itSong:
 234                                 return operator()(a.song, b.song);
 235                         default: // there's no other type, just silence compiler.
 236                                 return 0;
 237                 }
 238         }
 239         else
 240                 return a.type < b.type;
 241 }
 242
 243 void UpdateSongList(Menu<Song> *menu)
 244 {
 245         bool bold = 0;
 246         for (size_t i = 0; i < menu->Size(); ++i)
 247         {
 248                 for (size_t j = 0; j < myPlaylist->Items->Size(); ++j)
 249                 {
 250                         if (myPlaylist->Items->at(j).GetHash() == menu->at(i).GetHash())
 251                         {
 252                                 bold = 1;
 253                                 break;
 254                         }
 255                 }
 256                 menu->Bold(i, bold);
 257                 bold = 0;
 258         }
 259         menu->Refresh();
 260 }
 261
 262 #ifdef HAVE_TAGLIB_H
 263 std::string FindSharedDir(Menu<Song> *menu)
 264 {
 265         SongList list;
 266         for (size_t i = 0; i < menu->Size(); ++i)
 267                 list.push_back(&(*menu)[i]);
 268         return FindSharedDir(list);
 269 }
 270
 271 std::string FindSharedDir(const SongList &v)
 272 {
 273         if (v.empty()) // this should never happen, but in case...
 274                 FatalError("empty SongList passed to FindSharedDir(const SongList &)!");
 275         size_t i = -1;
 276         std::string first = v.front()->GetDirectory();
 277         for (SongList::const_iterator it = ++v.begin(); it != v.end(); ++it)
 278         {
 279                 size_t j = 0;
 280                 std::string dir = (*it)->GetDirectory();
 281                 size_t length = std::min(first.length(), dir.length());
 282                 while (!first.compare(j, 1, dir, j, 1) && j < length && j < i)
 283                         ++j;
 284                 i = j;
 285         }
 286         return i ? first.substr(0, i) : "/";
 287 }
 288 #endif // HAVE_TAGLIB_H
 289
 290 std::string FindSharedDir(const std::string &one, const std::string &two)
 291 {
 292         if (one == two)
 293                 return one;
 294         size_t i = 0;
 295         while (!one.compare(i, 1, two, i, 1))
 296                 ++i;
 297         i = one.rfind("/", i);
 298         return i != std::string::npos ? one.substr(0, i) : "/";
 299 }
 300
 301 std::string GetLineValue(std::string &line, char a, char b, bool once)
 302 {
 303         int pos[2] = { -1, -1 };
 304         size_t i;
 305         for (i = line.find(a); i != std::string::npos && pos[1] < 0; i = line.find(b, i))
 306         {
 307                 if (i && line[i-1] == '\\')
 308                 {
 309                         i++;
 310                         continue;
 311                 }
 312                 if (once)
 313                         line[i] = 0;
 314                 pos[pos[0] >= 0] = i++;
 315         }
 316         pos[0]++;
 317         std::string result = pos[0] >= 0 && pos[1] >= 0 ? line.substr(pos[0], pos[1]-pos[0]) : "";
 318         for (i = result.find("\\\""); i != std::string::npos; i = result.find("\\\""))
 319                 result.replace(i, 2, "\"");
 320         return result;
 321 }
 322
 323 std::string ExtractTopDirectory(const std::string &s)
 324 {
 325         size_t slash = s.rfind("/");
 326         return slash != std::string::npos ? s.substr(++slash) : s;
 327 }
 328
 329 std::basic_string<my_char_t> Scroller(const std::basic_string<my_char_t> &str, size_t &pos, size_t width)
 330 {
 331         std::basic_string<my_char_t> s(str);
 332         if (!Config.header_text_scrolling)
 333                 return s;
 334         std::basic_string<my_char_t> result;
 335         size_t len = Window::Length(s);
 336
 337         if (len > width)
 338         {
 339                 s += U(" ** ");
 340                 len = 0;
 341                 std::basic_string<my_char_t>::const_iterator b = s.begin(), e = s.end();
 342                 for (std::basic_string<my_char_t>::const_iterator it = b+pos; it < e && len < width; ++it)
 343                 {
 344                         if ((len += wcwidth(*it)) > width)
 345                                 break;
 346                         result += *it;
 347                 }
 348                 if (++pos >= s.length())
 349                         pos = 0;
 350                 for (; len < width; ++b)
 351                 {
 352                         if ((len += wcwidth(*b)) > width)
 353                                 break;
 354                         result += *b;
 355                 }
 356         }
 357         else
 358                 result = s;
 359         return result;
 360 }
 361
 362 #ifdef HAVE_CURL_CURL_H
 363 size_t write_data(char *buffer, size_t size, size_t nmemb, void *data)
 364 {
 365         size_t result = size*nmemb;
 366         static_cast<std::string *>(data)->append(buffer, result);
 367         return result;
 368 }
 369 #endif // HAVE_CURL_CURL_H
 370