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