src/util.cpp

   1 /*
   2 * Copyright (C) 2010 Toni Gundogdu.
   3 *
   4 * This program is free software: you can redistribute it and/or modify
   5 * it under the terms of the GNU General Public License as published by
   6 * the Free Software Foundation, either version 3 of the License, or
   7 * (at your option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "config.h"
  19
  20 #include <QApplication>
  21 #include <QTranslator>
  22 #include <QMessageBox>
  23 #include <QProcess>
  24 #include <QWidget>
  25 #include <QString>
  26 #include <QPoint>
  27 #include <QDebug>
  28 #include <QSize>
  29 #include <QDir>
  30
  31 #include "Log.h"
  32 #include "util.h"
  33
  34 // main.cpp
  35 extern QMap<QString,QStringList> hosts;
  36 extern QMap<QString,QString> qmFiles;
  37 extern QStringList qmLangNames;
  38 extern NomNom::Feed feed;
  39 extern Log log;
  40
  41 namespace NomNom
  42 {
  43
  44 void
  45 restore_size (
  46   QSettings& s,
  47   QWidget *w,
  48   const QString& g,
  49   const QSize& defaultSize/*=(400,350)*/)
  50 {
  51   w->resize (s.value (QString ("%1/size").arg (g), defaultSize).toSize ());
  52 }
  53
  54 void
  55 restore_pos (
  56   QSettings& s,
  57   QWidget *w,
  58   const QString& g,
  59   const QPoint& defaultPos/*=(200,200)*/)
  60 {
  61   w->move (s.value (QString ("%1/pos").arg (g), defaultPos).toPoint ());
  62 }
  63
  64 void
  65 save_size (QSettings& s, QWidget *w, const QString& g)
  66 {
  67   s.setValue (QString ("%1/size").arg (g), w->size ());
  68 }
  69
  70 void
  71 save_pos (QSettings& s, QWidget *w, const QString& g)
  72 {
  73   s.setValue (QString ("%1/pos").arg (g), w->pos ());
  74 }
  75
  76 void
  77 info (QWidget *p, const QString& m)
  78 {
  79   p->show (); // Make sure window is not hidden (e.g. minimized to tray).
  80   p->showNormal ();
  81   QMessageBox::information (p, QCoreApplication::applicationName(), m);
  82 }
  83
  84 void
  85 crit (QWidget *p, const QString& m)
  86 {
  87   p->show (); // See `info' function above.
  88   p->showNormal ();
  89   QMessageBox::critical (p, QCoreApplication::applicationName (), m);
  90 }
  91
  92 QMessageBox::StandardButton
  93 ask (QWidget *p, const QString& m, QMessageBox::StandardButtons b/*=Yes|No*/)
  94 {
  95   p->show (); // See `info' function above.
  96   p->showNormal ();
  97   return QMessageBox::question(p, QCoreApplication::applicationName(), m, b);
  98 }
  99
 100 static QFileInfoList
 101 scan_dir (const QString path, const bool show_paths)
 102 {
 103   const QDir dir (QDir::toNativeSeparators (path));
 104
 105   if (show_paths)
 106     qDebug () << dir.absolutePath ();
 107
 108   return dir.entryInfoList (QStringList( "*.qm"), QDir::Files);
 109 }
 110
 111 QMap<QString,QString>
 112 find_qm (QStringList& langNames)
 113 {
 114   QSettings s;
 115
 116   bool show_paths = false;
 117
 118   const QString qmShowPaths = "qmShowPaths";
 119   if (s.contains (qmShowPaths))
 120     show_paths = s.value (qmShowPaths).toBool ();
 121
 122   if (show_paths)
 123     qDebug () << "qm search paths:";
 124
 125   QStringList paths;
 126
 127   const QString qmPath = "qmPath";
 128   if (s.contains (qmPath))
 129     paths << s.value (qmPath).toString ();
 130
 131   paths
 132       << QDir::currentPath () + "/tr"
 133       << QDir::homePath () + "/.config/nomnom/tr"
 134       << QDir::homePath () + "/.local/share/nomnom/tr"
 135 #ifdef INSTALL_PREFIX
 136       << QString (INSTALL_PREFIX) + "/share/nomnom/tr"
 137 #endif
 138       ;
 139
 140   QFileInfoList lst;
 141
 142   foreach (QString p, paths)
 143   lst << scan_dir (p, show_paths);
 144
 145   QMap<QString,QString> map;
 146   QTranslator t;
 147
 148   foreach (QFileInfo fi, lst)
 149   {
 150
 151     t.load (fi.filePath ());
 152
 153     const QString langName = t.translate ("MainWindow", "English");
 154
 155     if (map.contains (langName))   // Skip duplicates.
 156       {
 157         if (map[langName] == fi.filePath ())
 158           continue;
 159       }
 160
 161     map[langName] = fi.filePath ();
 162
 163     langNames << langName;
 164   }
 165
 166   return map;
 167 }
 168
 169 bool
 170 choose_lang (QWidget *p, QString& langName)
 171 {
 172   bool showPaths = false;
 173   QStringList langNamesWithPaths;
 174
 175   const QString key = "qmShowPaths";
 176   QSettings s;
 177
 178   if (s.contains (key))
 179     {
 180
 181       showPaths = s.value (key).toBool ();
 182
 183       if (showPaths)
 184         {
 185
 186           langNamesWithPaths << "English [default, built-in]";
 187
 188           QMapIterator<QString,QString> iter (qmFiles);
 189
 190           while (iter.hasNext ())
 191             {
 192
 193               iter.next ();
 194
 195               langNamesWithPaths << QString ("%1 [%2]")
 196                                  .arg (iter.key ())
 197                                  .arg (iter.value ());
 198             }
 199
 200         }
 201     }
 202
 203   bool ok  = false;
 204
 205   langName = QInputDialog::getItem (
 206                p,
 207                QObject::tr ("Select language"),
 208                QObject::tr ("Language:"),
 209                showPaths ? langNamesWithPaths : qmLangNames,
 210                0,
 211                false,
 212                &ok
 213              );
 214
 215   langName = langName.split ("[")[0].simplified ();
 216
 217   return ok;
 218 }
 219
 220 QTranslator*
 221 load_qm ()
 222 {
 223   QString langName;
 224
 225   QSettings s;
 226   if (s.contains("language"))
 227     {
 228       const QString v = s.value("language").toString();
 229
 230       if (v == "English")
 231         return NULL;
 232
 233       if (qmFiles.contains(v))
 234         langName = v;
 235     }
 236
 237   if (langName.isEmpty())
 238     {
 239       if (!choose_lang(NULL, langName))
 240         return NULL;
 241     }
 242
 243   s.setValue("language", langName);
 244
 245   QTranslator *t = new QTranslator;
 246   t->load(qmFiles[langName]);
 247
 248   return t;
 249 }
 250
 251 bool
 252 parse_quvi_version (const QString& path, QString& output)
 253 {
 254   output.clear ();
 255
 256   // Use command path (arg0) and "--version" only.
 257
 258   QStringList args =
 259     QStringList () << path.split (" ").takeFirst () << "--version";
 260
 261   log << args.join (" ");
 262
 263   const QString cmdPath = args.takeFirst ();
 264
 265   QProcess proc;
 266   proc.setProcessChannelMode (QProcess::MergedChannels);
 267   proc.start (cmdPath, args);
 268
 269   if (!proc.waitForFinished ())
 270     {
 271
 272       output =
 273         QObject::tr ("error: %1: %2")
 274         .arg (cmdPath)
 275         .arg (proc.errorString ());
 276
 277       return false;
 278     }
 279
 280   output = QString::fromLocal8Bit (proc.readAll ()).simplified ();
 281
 282   return true;
 283 }
 284
 285 bool
 286 parse_quvi_support (const QString& path, QString& errmsg)
 287 {
 288   errmsg.clear ();
 289
 290   // Use command path (arg0) and "--support" only.
 291
 292   QStringList args =
 293     QStringList () << path.split (" ").takeFirst () << "--support";
 294
 295   log << args.join (" ");
 296
 297   const QString cmdPath = args.takeFirst ();
 298
 299   QProcess proc;
 300   proc.setProcessChannelMode(QProcess::MergedChannels);
 301   proc.start(cmdPath, args);
 302
 303   if (!proc.waitForFinished())
 304     {
 305
 306       errmsg =
 307         QObject::tr("error: %1: %2")
 308         .arg(cmdPath)
 309         .arg(proc.errorString ());
 310
 311       return false;
 312     }
 313
 314   const QRegExp re("(.*)\\s+(.*)$");
 315
 316   const QString output =
 317     QString::fromLocal8Bit(proc.readAll());
 318
 319   foreach (QString ln, output.split("\n"))
 320   {
 321
 322     if (ln.isEmpty())
 323       continue;
 324
 325     log << ln;
 326
 327     if (re.indexIn(ln) != -1)
 328       {
 329
 330         const QString host  = re.cap (1).simplified ();
 331         QStringList formats = re.cap (2).simplified ().split ("|");
 332
 333         // Keep "default" at the beginning of the list.
 334
 335         const QString top = formats.takeFirst ();
 336         formats.sort ();
 337         formats.prepend (top);
 338
 339         hosts[host] = formats;
 340       }
 341   }
 342
 343   return true;
 344 }
 345
 346 static bool
 347 filter_title (
 348   QWidget *p,
 349   const QString& user_regexp,
 350   const QString& title,
 351   QString& dst)
 352 {
 353   QString pattern;
 354
 355   bool g = false;
 356   bool i = false;
 357
 358   QRegExp rx("^\\/(.*)\\/(.*)$");
 359
 360   if (rx.indexIn (user_regexp) != -1)
 361     {
 362       pattern = rx.cap (1);
 363       g = rx.cap (2).contains ("g");
 364       i = rx.cap (2).contains ("i");
 365     }
 366   else
 367     {
 368       NomNom::crit (p,
 369                     QObject::tr ("Expected Perl-style regular expression, e.g. /pattern/flags"));
 370       return false;
 371     }
 372
 373   rx.setPattern (pattern);
 374
 375   rx.setCaseSensitivity (
 376     i
 377     ? Qt::CaseInsensitive
 378     : Qt::CaseSensitive
 379   );
 380
 381   int pos = 0;
 382
 383   while ( (pos = rx.indexIn (title, pos)) != -1)
 384     {
 385       dst += rx.cap (1);
 386       pos += rx.matchedLength ();
 387       if (!g) break;
 388     }
 389
 390   dst = dst.simplified ();
 391
 392   return true;
 393 }
 394
 395 bool
 396 format_filename (
 397   QWidget *p,
 398   const QString& user_regexp,
 399   const QString& title,
 400   const QString& suffix,
 401   const QString& host,
 402   const QString& id,
 403   QString& dst)
 404 {
 405   // Assumes dst to contain the "filename format".
 406
 407   QString filtered_title;
 408
 409   const bool ok = filter_title (
 410                     p,
 411                     user_regexp,
 412                     title,
 413                     filtered_title
 414                   );
 415
 416   if (!ok)
 417     return ok;
 418
 419   dst.replace ("%t", filtered_title);
 420   dst.replace ("%s", suffix);
 421   dst.replace ("%h", host);
 422   dst.replace ("%i", id);
 423
 424   dst = dst.simplified ();
 425
 426   return true;
 427 }
 428
 429 QString
 430 to_process_errmsg (QProcess::ProcessError n)
 431 {
 432   QString e;
 433
 434   switch (n)
 435     {
 436
 437     case QProcess::FailedToStart:
 438       e = QObject::tr (
 439             "The process failed to start. "
 440             "Either the invoked program is missing, or you may have "
 441             "insufficient permissions to invoke the program."
 442           );
 443       break;
 444
 445     case QProcess::Crashed:
 446       e = QObject::tr (
 447             "The process crashed some time after starting successfully."
 448           );
 449       break;
 450
 451     case QProcess::Timedout:
 452       e = QObject::tr (
 453             "The last waitFor...() function timed out. "
 454             "The state of QProcess is unchanged, and you can try calling "
 455             "waitFor...() again."
 456           );
 457       break;
 458
 459     case QProcess::WriteError:
 460       e = QObject::tr (
 461             "An error occurred when attempting to write to the process. "
 462             "For example, the process may not be running, or it may have closed "
 463             "its input channel."
 464           );
 465       break;
 466
 467     case QProcess::ReadError:
 468       e = QObject::tr (
 469             "An error occurred when attempting to read from the process. "
 470             "For example, the process may not be running."
 471           );
 472       break;
 473
 474     case QProcess::UnknownError:
 475     default:
 476       e = QObject::tr (
 477             "An unknown error occurred. This is the default return value "
 478             "of error()."
 479           );
 480       break;
 481
 482     }
 483
 484   return e;
 485 }
 486
 487 bool
 488 choose_from_feed (QWidget *parent, QString& dst)
 489 {
 490   if (feed.isEmpty())
 491     return false;
 492
 493   FeedIterator i(feed);
 494   QStringList items;
 495
 496   while (i.hasNext())
 497     items << i.next().first;
 498
 499   bool ok = false;
 500
 501   QString title = QInputDialog::getItem (
 502                     parent,
 503                     QObject::tr ("Choose video"),
 504                     QObject::tr ("Video"),
 505                     items,
 506                     0,
 507                     false,
 508                     &ok
 509                   );
 510
 511   if (ok)
 512     {
 513       i = FeedIterator(feed);
 514       while (i.hasNext())
 515         {
 516           QPair<QString,QString> p = i.next();
 517           if (p.first == title)
 518             {
 519               dst = p.second;
 520               break;
 521             }
 522         }
 523     }
 524
 525   return ok;
 526 }
 527
 528 QString
 529 reverse_line_order(const QString& s, const QString& sep/*="\n"*/)
 530 {
 531   QStringListIterator
 532   i(s.split(sep, QString::SkipEmptyParts));
 533
 534   i.toBack();
 535
 536   QString r;
 537   while(i.hasPrevious())
 538     r += i.previous() + "\n";
 539
 540   return r;
 541 }
 542
 543 } // End of namespace.
 544
 545 // vim: set ts=2 sw=2 tw=72 expandtab: