stationlistmodel.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2008-2010  Lukas Sommer < SommerLuk at gmail dot com >

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "stationlistmodel.h"

#include "folderpropertiesdialog.h"
#include "includekio.h"
#include "stationlistwidget.h"
#include "settings_general.h"
#include <QAbstractItemModel>
#include <QApplication>
#include <QClipboard>
#include <QFile>
#include <QItemSelection>
#include <QMimeData>
#include <QXmlStreamReader>
#include <KLocale>
#include <KProgressDialog>
#include <KStandardDirs>
#include <KTemporaryFile>
#define AND  &&
#define OR  ||
#define NOT  !
#define EQUAL  ==

stationlistModel::stationlistModel(stationlistWidget *parent,
                                   QWidget *mainWidget) : QAbstractItemModel(parent)
{
  // variables
  QXmlStreamReader stationlistReader;
  QFile stationlistFile;
  stationlistItem *actualFolder;
  stationlistItem *temp_item;
  QString temp_string;
  QModelIndexList expandedRows;

  // general setup
  m_mainWidget = mainWidget;
  view = parent;
  m_listOfStreamsOfWhichTheUserWantsThatTheyRip = 0;
  // setup data model
  rootItem = new stationlistItem("");
  stationlistFile.setFileName(helper_stationlistXmlFilepath());
  if (stationlistFile.open(QIODevice::ReadOnly)) {
    stationlistReader.setDevice(&stationlistFile);
    actualFolder = rootItem;
    while (!stationlistReader.atEnd()) {
      stationlistReader.readNext();
      if (stationlistReader.name() == "folder") {
        if (stationlistReader.isStartElement()) {
          temp_item = new stationlistItem(stationlistReader.attributes().value("name").toString());
          actualFolder->appendChild(temp_item);
          actualFolder = temp_item;
          if (stationlistReader.attributes().value("expanded").toString() == "true") {
            expandedRows.append(modelindexOfItem(temp_item, 0));
          };
        } else if (stationlistReader.isEndElement()) {
          actualFolder = actualFolder->parent();
          if (!actualFolder) { // should never happen for properly written xml lists
            actualFolder = rootItem;
          };
        };
      } else if (stationlistReader.name() == "stream" && stationlistReader.isStartElement()) {
        temp_item = helper_createStreamItem(new radioStation(this,
                                                       m_mainWidget,
                                                       stationlistReader.readElementText()));
        actualFolder->appendChild(temp_item);
      };
    };
  };

  // initialize attributes
  recalculate_numberOfActiveStreams_and_bandwidth(); // now possible (after making stationlist)

  connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
          this, SLOT(recalculate_numberOfActiveStreams_and_bandwidth()));
  connect(this, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
          this, SLOT(recalculate_numberOfActiveStreams_and_bandwidth()));
  view->setModel(this);
  foreach (const QModelIndex &m_index, expandedRows) {
    view->expand(m_index);
  };
  helper_writeStationList();  /* We do this because when radioStation can't
  open the file, it creates a new one. Probaby this won't happen, but we have to make sure
  that the list in the general config file is actual. (We must du this _after_ setting this
  object as model of the view because helper_writeStationList() relays on an existing view. */
  connect(view->selectionModel(),
          SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
          this,
          SLOT(recalculateSelectedStreams()));
}

stationlistModel::~stationlistModel()
{
  delete rootItem;
}

void stationlistModel::helper_connectSignalsAndSlots(radioStation *m_stream)
{
    connect(m_stream, SIGNAL(streamNameChanged(void *, PropertyValue)),
            this, SLOT(reloadStreamName(void *)));
    connect(m_stream, SIGNAL(uriChanged(void *, PropertyValue)),
            this, SLOT(reloadUri(void *)));
    connect(m_stream, SIGNAL(statusChanged(void *, PropertyValue)),
            this, SLOT(reloadStatus(void *)));
    connect(m_stream, SIGNAL(errorChanged(void *, PropertyValue)),
            this, SLOT(reloadStatus(void *)));
    connect(m_stream, SIGNAL(songChanged(void *, PropertyValue)),
            this, SLOT(reloadSong(void *)));
    connect(m_stream, SIGNAL(dataSizeChanged(void *, PropertyValue)),
            this, SLOT(reloadDataSize(void *)));
    connect(m_stream, SIGNAL(bitrateChanged(void *, PropertyValue)),
            this, SLOT(reloadBitrate(void *)));
    connect(m_stream, SIGNAL(bitrateChanged(void *, PropertyValue)),
            this, SLOT(recalculate_numberOfActiveStreams_and_bandwidth()));
    connect(m_stream, SIGNAL(metaIntervalChanged(void *, PropertyValue)),
            this, SLOT(reloadMetaInterval(void *)));
    connect(m_stream, SIGNAL(metaInterval_milliSecondsChanged(void *, PropertyValue)),
            this, SLOT(reloadMetaInterval_milliSeconds(void *)));
    connect(m_stream, SIGNAL(serverNameChanged(void *, PropertyValue)),
            this, SLOT(reloadServerName(void *)));
    connect(m_stream, SIGNAL(relayPortChanged(void *, PropertyValue)),
            this, SLOT(reloadRelayPort(void *)));
    connect(m_stream, SIGNAL(running()),
            this, SLOT(recalculate_numberOfActiveStreams_and_bandwidth()));
    connect(m_stream, SIGNAL(not_running()),
            this, SLOT(recalculate_numberOfActiveStreams_and_bandwidth()));
}

inline QString stationlistModel::helper_stationlistXmlFilepath()
{
  return KStandardDirs::locateLocal("appdata", "stationlist.xml");
}

int stationlistModel::rowCount (const QModelIndex & parent) const
{
  // variables
  stationlistItem *parentItem = item(parent);

  // code
  if (parent.column() > 0) {
    return 0;
  };
  return parentItem->childCount();
}

int stationlistModel::columnCount (const QModelIndex &) const
{
  return 10;
}

QVariant stationlistModel::columnInfo(const columnInfoType type,
                                      const int column,
                                      const radioStation *stream,
                                      const quint64 value) const
{
  QVariant temp;

  switch (type) {  // make sure that row is valid to prevent a memory access failure
    case columnHeaderTitle:
    case columnHeaderToolTip:
    case columnHeaderWhatsThis:
    case columnWidth:
    case setColumnWidth:
    case columnVisibility:
    case setColumnVisibility:
      break;  // These functions are known to not make use of the row.
    default:  // Else we break as a precaution we break up here.
      if (stream == 0) {
        return QVariant();
      };
  }
  /* IF data is requested that is NOT depending on the "row"
  *  THEN no check is needed.
  *  ELSE (=when data is depending on the "row") we check if it is a valid row.
  *  If not, we return a QVariant(). This is important, because the rest of this
  *  function body assumes that "row" is valid and uses it for QList::at(row) - and
  *  when "row" is invalid, this function leeds to a crash.
  *
  *  I use the "switch" systax because this looks clearer than an "if" construct.
  *  And I test for the cases where the row is NOT important - this way (when one
  *  day the enum gets more items that depend on the row - and we forget to change
  *  it here) at least we don't get a crash.
  *
  *  We don't test if "column" is valid, because the rest of the function is a
  *  switch-case, and when there nothing matches, an invalid QVariant is returned. */

  switch (column) {

    case 0:
    {
      switch (type) {
        case columnHeaderTitle:
          return i18nc("@title:column", "stream name");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return QVariant();
        case columnWidth:
          return settings_general::columnWidth_streamName();
        case setColumnWidth:
          settings_general::setColumnWidth_streamName(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_streamName();
        case setColumnVisibility:
          settings_general::setColumnVisibility_streamName(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->streamName());
          return temp;
      };
      break;
    }

    case 1:
    {
      switch (type) {
        case columnHeaderTitle:
          return i18nc("@title:column", "URL");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return QVariant();
        case columnWidth:
          return settings_general::columnWidth_uri();
        case setColumnWidth:
          settings_general::setColumnWidth_uri(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_uri();
        case setColumnVisibility:
          settings_general::setColumnVisibility_uri(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->uri());
          return temp;
      };
      break;
    }

    case 2:
    {
      switch (type) {
        case columnHeaderTitle:
          return i18nc("@title:column", "status");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return QVariant();
        case columnWidth:
          return settings_general::columnWidth_statusAndError();
        case setColumnWidth:
          settings_general::setColumnWidth_statusAndError(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_statusAndError();
        case setColumnVisibility:
          settings_general::setColumnVisibility_statusAndError(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          PropertyValue my_statusAndError;
          if (stream->error().formatedValue.isEmpty()) {
            my_statusAndError.formatedValue = stream->status().formatedValue;
            my_statusAndError.toolTip = stream->status().toolTip;
            my_statusAndError.whatsThis = stream->status().whatsThis;
          } else {
            my_statusAndError.toolTip = stream->error().toolTip;
            my_statusAndError.whatsThis = stream->error().whatsThis;
            if (stream->status().formatedValue.isEmpty()) {
              my_statusAndError.formatedValue = stream->error().formatedValue;
            } else {
              my_statusAndError.formatedValue = QString(i18nc(
                "@item:intable This produces the status message from the actual status (%1) and "
                  "the error message (%3). Both of them are guaranteed to be not empty. %2 is "
                  "replaced by an en-dash (Unicode U+2013). Use it or replace it by something "
                  "what looks nicer in your language.",
                "%1 %2 %3",
                stream->status().formatedValue,
                QString(QChar(0x2013)),
                stream->error().formatedValue));
            };
          };
          my_statusAndError.internalValue = stream->status().internalValue;
          if ((!(stream->error().type == PropertyValue::unset)) ||
              (stream->status().type == PropertyValue::error)) {
            my_statusAndError.type = PropertyValue::error;
          } else if (my_statusAndError.formatedValue.isEmpty()) {
            my_statusAndError.type = PropertyValue::unset;
          } else {
            my_statusAndError.type = PropertyValue::value;
          };
          temp.setValue<PropertyValue>(my_statusAndError);
          return temp;
      };
      break;
    }

    case 3:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column header of the column with the name of the actual track",
                        "track");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_song();
        case setColumnWidth:
          settings_general::setColumnWidth_song(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_song();
        case setColumnVisibility:
          settings_general::setColumnVisibility_song(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->song());
          return temp;
      };
      break;
    }

    case 4:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column", "track size");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_dataSize();
        case setColumnWidth:
          settings_general::setColumnWidth_dataSize(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_dataSize();
        case setColumnVisibility:
          settings_general::setColumnVisibility_dataSize(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->dataSize());
          return temp;
      };
      break;
    }

    case 5:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column", "bit rate");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_bitrate();
        case setColumnWidth:
          settings_general::setColumnWidth_bitrate(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_bitrate();
        case setColumnVisibility:
          settings_general::setColumnVisibility_bitrate(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->bitrate());
          return temp;
      };
      break;
    }

    case 6:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column The unit is KiB instead of kB. See "
                          "http://en.wikipedia.org/wiki/Binary_prefix for details.",
                        "meta data interval (KiB)");
        case columnHeaderToolTip:
          return  i18nc("@info:tooltip", "interval of meta data in bytes");
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_metaInterval();
        case setColumnWidth:
          settings_general::setColumnWidth_metaInterval(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_metaInterval();
        case setColumnVisibility:
          settings_general::setColumnVisibility_metaInterval(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->metaInterval());
          return temp;
      };
      break;
    }

    case 7:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column unit is millisecond", "meta data interval (ms)");
        case columnHeaderToolTip:
          return  i18nc("@info:tooltip", "interval of meta data in milliseconds");
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_metaInterval_milliSeconds();
        case setColumnWidth:
          settings_general::setColumnWidth_metaInterval_milliSeconds(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_metaInterval_milliSeconds();
        case setColumnVisibility:
          settings_general::setColumnVisibility_metaInterval_milliSeconds(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->metaInterval_milliSeconds());
          return temp;
      };
      break;
    }

    case 8:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column", "server name");
        case columnHeaderToolTip:
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_serverName();
        case setColumnWidth:
          settings_general::setColumnWidth_serverName(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_serverName();
        case setColumnVisibility:
          settings_general::setColumnVisibility_serverName(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->serverName());
          return temp;
      };
      break;
    }

    case 9:
    {
      switch (type) {
        case columnHeaderTitle:
          return  i18nc("@title:column 'relay port' means 'the port that the relay server uses'",
                        "relay port");
        case columnHeaderToolTip:
          return  i18nc("@info:tooltip", "port of the relay server");
        case columnHeaderWhatsThis:
          return  QVariant();
        case columnWidth:
          return settings_general::columnWidth_relayPort();
        case setColumnWidth:
          settings_general::setColumnWidth_relayPort(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnVisibility:
          return settings_general::columnVisibility_relayPort();
        case setColumnVisibility:
          settings_general::setColumnVisibility_relayPort(value);
          settings_general::self()->writeConfig();
          return QVariant();
        case columnData:
          temp.setValue<PropertyValue>(stream->relayPort());
          return temp;
      };
      break;
    }

  /* No "default:"! This way we get a compiler warning when one day
  *  the enum type has more items and we forget to implement this here. */

  };
  return QVariant();  // Return an invalid QVariant if the given "column" was invalid.
}

QList<radioStation *> stationlistModel::helper_listOfAllStreams(stationlistItem *parentItem)
{
  QList<radioStation *> list;
  if (parentItem->type() == stationlistItem::stream) {
    list.append(parentItem->streamObject());
  } else {
    for (int i = 0; i < parentItem->childCount(); ++i) {
      list << helper_listOfAllStreams(parentItem->child(i));
    };
  };
  return list;
}

void stationlistModel::recalculate_numberOfActiveStreams_and_bandwidth()
{
  // variables
  int i;
  int temp_numberOfActiveStreams = 0;
  quint64 temp_bandwidth = 0;
  QList<radioStation *> m_stationlist = helper_listOfAllStreams(rootItem);

  // code

  // calculate new values
  for (i=0; i < m_stationlist.size(); ++i) {
    if (m_stationlist.at(i)->status().internalValue.value<ripping::statusType>() != ripping::idle) {
      temp_numberOfActiveStreams++;
      if (m_stationlist.at(i)->bitrate().type == PropertyValue::value) {
        temp_bandwidth = temp_bandwidth +
                             m_stationlist.at(i)->bitrate().internalValue.toULongLong();
      };
    };
  };

  // actualize properties if necessary
  if (internal_numberOfActiveStreams != temp_numberOfActiveStreams) {
    internal_numberOfActiveStreams = temp_numberOfActiveStreams;
    emit numberOfActiveStreamsChanged();
    if (internal_numberOfActiveStreams == 0) {
      emit numberOfActiveStreamsIsZero();
    };
  };
  if (internal_bandwidth != temp_bandwidth) {
    internal_bandwidth = temp_bandwidth;
    emit bandwidthChanged();
  };
}

QModelIndex stationlistModel::modelindexOfItem(stationlistItem *item, int column)
{
  if (item == rootItem || item == 0) {
    return QModelIndex();
  } else {
    return index(item->row(), column, modelindexOfItem(item->parent(), 0));
  };
}

void stationlistModel::reloadStreamName(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 0),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 0));
}

void stationlistModel::reloadUri(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 1),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 1));
}

void stationlistModel::reloadStatus(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 2),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 2));
  emit statusChanged();
}

void stationlistModel::reloadSong(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 3),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 3));
}

void stationlistModel::reloadDataSize(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 4),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 4));
}

void stationlistModel::reloadBitrate(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 5),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 5));
}

void stationlistModel::reloadMetaInterval(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 6),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 6));
}

void stationlistModel::reloadMetaInterval_milliSeconds(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 7),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 7));
}

void stationlistModel::reloadServerName(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 8),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 8));
}

void stationlistModel::reloadRelayPort(void *stationIndex)
{
  emit dataChanged(modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 9),
                   modelindexOfItem(static_cast<stationlistItem *>(stationIndex), 9));
  emit relayportChanged();
}

QVariant stationlistModel::headerData(int section, Qt::Orientation orientation, int role) const
{
     if (orientation EQUAL Qt::Vertical) {
       if (role == Qt::DisplayRole) {
         return (int(section+1));
       } else {
         return QVariant();
       };
     } else {
       switch (role) {
         case Qt::DisplayRole:
           return columnInfo(columnHeaderTitle, section);
         case Qt::ToolTipRole:
           return columnInfo(columnHeaderToolTip, section);
         case Qt::WhatsThisRole:
           return columnInfo(columnHeaderWhatsThis, section);
         default:
           return QVariant();  // other "display roles" aren't supported.
       };
     };
     return QVariant();  // This point should never be reached. It just exists
                         // to be sure to deliver a return value, also when
                         // I introduce new bugs in the code above.
}

QVariant stationlistModel::data(const QModelIndex &index, int role) const
{
  //variables
  QVariant returnValue;
  stationlistItem *indexItem;

  //code
  if ((index.model() EQUAL this) AND (index.isValid())) {
    indexItem = static_cast<stationlistItem *>(index.internalPointer());
    if (indexItem->type() == stationlistItem::stream) {
      switch (role) {
        case Qt::DisplayRole:
          returnValue = columnInfo(columnData, index.column(), indexItem->streamObject())
                          .value<PropertyValue>().formatedValue;
          break;
        case Qt::ToolTipRole:
          returnValue =
            columnInfo(columnData, index.column(), indexItem->streamObject()).
              value<PropertyValue>().toolTip;
          break;
        case Qt::WhatsThisRole:
          returnValue =
            columnInfo(columnData, index.column(), indexItem->streamObject()).
              value<PropertyValue>().whatsThis;
          break;
        case Qt::TextAlignmentRole:
          returnValue = static_cast<int>(
            columnInfo(columnData, index.column(), indexItem->streamObject()).
              value<PropertyValue>().formatedValueAlignment);
          break;
        case Qt::DecorationRole:
          if (index.column() == 0) {
            returnValue = KIcon("audio-x-generic");
          };
          break;
        default: // other "display roles" aren't supported.
          returnValue = QVariant();
          break;
      };
    } else {
      if (role == Qt::DisplayRole AND index.column() == 0) {
        returnValue = indexItem->folderName();
      } else if (role == Qt::DecorationRole AND index.column() == 0) {
        returnValue = KIcon("folder");
      };
    };
  };

  //return
  return returnValue;
}

void stationlistModel::sort(int column, Qt::SortOrder order)
{
  // pre-check
  if (column < 0 || column >= columnCount()) {  // nothing to do
    return;
  };

  // variables
  PropertyValue temp;
  QList<radioStation *> sorted_list;
  QModelIndexList temp_indexList;
  QList<stationlistItem *> selection;

  // code

  // save the selection
  /*temp_indexList = view->selectionModel()->selectedRows();
  foreach (const QModelIndex & tempModelIndex, temp_indexList) {
    selection.append(static_cast<stationlistItem *>(tempModelIndex.internalPointer());
  };*/

  // sort
  sortChildItems(rootItem, column, order);

  // restore selection

  // save the new sort order
  settings_general::setSortingAscendingly(order == Qt::AscendingOrder);
  settings_general::setSortByColumn(column);
  settings_general::self()->writeConfig();
}

void stationlistModel::helper_moveItems(const QModelIndex &oldParent,
                                        int first,
                                        int last,
                                        const QModelIndex &newParent,
                                        int newRow)
{
  QList<stationlistItem *> itemList = helper_removeItems(oldParent, first, last);
  helper_insertItems(itemList, newParent, newRow);
}

void stationlistModel::sortChildItems(stationlistItem *parent, int column, Qt::SortOrder order)
{
  // consts
  const int childCount = parent->childCount();
  const int childCount_1 = childCount -1;
  QModelIndex parentIndex = modelindexOfItem(parent, 0);

  // variables
  int i;

  // code
  for (i = 0; i < childCount_1; ++i) {
    for (int j = i + 1; j < childCount; ++j) {
      if (helper_firstIsAfterSecond(parent->child(i), parent->child(j), column, order)) {
        helper_moveItems(parentIndex, j, j, parentIndex, i);
      };
    };
  };
  for (i = 0; i < childCount; ++i) {
    sortChildItems(parent->child(i), column, order);
  };
}

bool stationlistModel::helper_isNumericValue(const QVariant & value)
{
  // variables
  QMetaType::Type type;

  // code
  type = static_cast<QMetaType::Type>(value.type());
  return (type == QMetaType::Int ||
          type == QMetaType::UInt ||
          type == QMetaType::Double ||
          type == QMetaType::Long ||
          type == QMetaType::LongLong ||
          type == QMetaType::Short ||
          type == QMetaType::Char ||
          type == QMetaType::ULong ||
          type == QMetaType::ULongLong ||
          type == QMetaType::UShort ||
          type == QMetaType::UChar ||
          type == QMetaType::Float ||
          // I don't understand why QString() is necessary, but without it doesn't work.
          value.typeName() == QString("ripping::statusType"));
}

qlonglong stationlistModel::helper_toLongLong(const PropertyValue & value)
{
  // I don't understand why QString() is necessary, but without it doesn't work
  if (value.internalValue.typeName() == QString("ripping::statusType")) {
    return value.internalValue.value<ripping::statusType>();
  } else {
    return value.internalValue.toLongLong();
  };
}

bool stationlistModel::helper_firstIsAfterSecond(stationlistItem *firstItem,
                                                 stationlistItem *secondItem,
                                                 int column,
                                                 Qt::SortOrder order)
{
  if (firstItem->type() == stationlistItem::stream) {
    if (secondItem->type() == stationlistItem::stream) {  // both are streams
      return helper_firstIsAfterSecond(
        columnInfo(columnData, column, firstItem->streamObject()).value<PropertyValue>(),
        columnInfo(columnData, column, secondItem->streamObject()).value<PropertyValue>(),
        order);
    } else {  // first is stream, second is folder
      return true;
    };
  } else {
    if (secondItem->type() == stationlistItem::stream) {  // first is folder, second is stream
      return false;
    } else {  // both are folders
      if (order == Qt::AscendingOrder) {
        return (QString::localeAwareCompare(firstItem->folderName(), secondItem->folderName()) >=
                  0);
      } else {
        return (QString::localeAwareCompare(firstItem->folderName(), secondItem->folderName()) <=
                  0);
      };
    };
  };
  kDebug() << "Function hasn't calculated a return value. TRUE is returned to prevent a crash.";
  return true;
}

bool stationlistModel::helper_firstIsAfterSecond(const PropertyValue & firstValue,
                                                 const PropertyValue & secondValue,
                                                 Qt::SortOrder order)
{
  // code
  if (order == Qt::AscendingOrder) {
      switch (firstValue.type) {
          case PropertyValue::unset:
              return (secondValue.type == PropertyValue::unset);
          case PropertyValue::value:
              if (secondValue.type == PropertyValue::unset) {
                  return true;
              } else if (secondValue.type == PropertyValue::error) {
                  return false;
              } else {
                  if (helper_isNumericValue(firstValue.internalValue) &&
                      helper_isNumericValue(secondValue.internalValue)) {
                      return helper_toLongLong(firstValue) >= helper_toLongLong(secondValue);
                  } else {
                      return QString::localeAwareCompare(firstValue.formatedValue,
                                                         secondValue.formatedValue) >= 0;
                  };
              };
          case PropertyValue::error:
              if (secondValue.type == PropertyValue::error) {
                  return QString::localeAwareCompare(firstValue.formatedValue,
                                                     secondValue.formatedValue) >= 0;
              } else {
                  return true;
              };
      };
  } else {
      switch (firstValue.type) {
          case PropertyValue::unset:
              return true;
          case PropertyValue::value:
              if (secondValue.type == PropertyValue::unset) {
                  return false;
              } else if (secondValue.type == PropertyValue::error) {
                  return true;
              } else {
                  if (helper_isNumericValue(firstValue.internalValue) &&
                      helper_isNumericValue(secondValue.internalValue)) {
                      return helper_toLongLong(firstValue) <= helper_toLongLong(secondValue);
                  } else {
                      return QString::localeAwareCompare(firstValue.formatedValue,
                                                         secondValue.formatedValue) <= 0;
                  };
              };
          case PropertyValue::error:
              if (secondValue.type == PropertyValue::error) {
                  return QString::localeAwareCompare(firstValue.formatedValue,
                                                     secondValue.formatedValue) <= 0;
              } else {
                  return false;
              };
      };
  };
  kDebug() << "Function hasn't calculated a return value. TRUE is returned to prevent a crash.";
  return true;
}

bool stationlistModel::helper_isInTree(stationlistItem *child, stationlistItem *parent)
{
  if (child == 0 OR parent == 0) {  // test if both pointern are not 0
    return false;
  };
  if (child->parent() == 0) {  // test if "child" has a parent
    return false;
  };
  if (child->parent() == parent) {
    return true;
  } else {
    return helper_isInTree(child->parent(), parent);
  };
}

QList<stationlistItem *> stationlistModel::helper_removeItems(const QModelIndex &parent,
                                                              int first,
                                                              int last)
{
  // variables
  QList<stationlistItem *> returnValue;
  stationlistItem *parentItem = item(parent);

  // code
  beginRemoveRows(parent, first, last);
  for (int i = last; i >= first; --i) {
    returnValue.prepend(parentItem->child(i));
    returnValue.first()->detach();
  };
  endRemoveRows();
  return returnValue;
}

void stationlistModel::helper_insertItem(stationlistItem * item,
                                         const QModelIndex &parent,
                                         int row)
{
  QList<stationlistItem *> itemList;
  itemList.append(item);
  helper_insertItems(itemList, parent, row);
}

void stationlistModel::helper_insertItems(QList<stationlistItem *> itemList,
                                          const QModelIndex &parent,
                                          int row)
{
  // variables
  stationlistItem *parentItem = item(parent);

  // code
  beginInsertRows(parent, row, row + itemList.size() - 1);
  for (int i = 0; i < itemList.size(); ++i) {
    parentItem->insertChild(itemList.at(i), row + i);
  };
  endInsertRows();
}

stationlistItem *stationlistModel::helper_createStreamItem(radioStation *stream)
{
  // variables
  stationlistItem *returnValue;

  // code
  returnValue = new stationlistItem(stream);
  stream->setIndex(returnValue);
  helper_connectSignalsAndSlots(stream);
  return returnValue;
}

void stationlistModel::helper_addNewFolder(const QModelIndex & index)
{
  // variables
  int exitCode;
  stationlistItem *new_item, *parent_item;
  folderPropertiesDialog *dialog;

  // code
  dialog = new folderPropertiesDialog();
  exitCode = dialog->exec();
  if (exitCode == QDialog::Accepted) {  // insert the new station in our model
    new_item = new stationlistItem(dialog->centralWidget->text());
    parent_item = rootItem;
    if (index.isValid()) {
      if (static_cast<stationlistItem *>(index.internalPointer())->type() ==
            stationlistItem::folder) {
        parent_item = static_cast<stationlistItem *>(index.internalPointer());
      };
    };
    helper_insertItem(new_item,
                      modelindexOfItem(parent_item, 0),
                      parent_item->childCount());
    helper_selectAndScrollTo(QModelIndexList() << modelindexOfItem(new_item, 0));
    helper_writeStationList();
  };
}

void stationlistModel::helper_addNewStation(const QModelIndex & index)
{
  // variables
  radioStation *m_newStation;
  int exitCode;
  stationlistItem *new_item, *parent_item;

  // code
  m_newStation = new radioStation(this, m_mainWidget, QString());
  exitCode = m_newStation->execSettingsDialogWithoutApplyButton();
  if (exitCode == QDialog::Accepted) {  // insert the new station in our model
    new_item = helper_createStreamItem(m_newStation);
    parent_item = rootItem;
    if (index.isValid()) {
      if (static_cast<stationlistItem *>(index.internalPointer())->type() ==
            stationlistItem::folder) {
        parent_item = static_cast<stationlistItem *>(index.internalPointer());
      };
    };
    helper_insertItem(new_item,
                      modelindexOfItem(parent_item, 0),
                      parent_item->childCount());
    helper_selectAndScrollTo(QModelIndexList() << modelindexOfItem(new_item, 0));
    helper_writeStationList();
  } else {
    helper_deleteRadiostationobjectAndRemoveConfigfiles(m_newStation);
  };
}

void stationlistModel::helper_selectAndScrollTo(const QModelIndexList & modelIndexList)
{
  if (modelIndexList.size() > 0) {
    view->clearSelection();
    foreach (const QModelIndex & m_index, modelIndexList) {
      view->selectionModel()->select(m_index,
                                     QItemSelectionModel::Select | QItemSelectionModel::Rows);
      view->scrollToRow(m_index);  // necessary to expand all selected items
    };
  };
}

void stationlistModel::addNewStationInFolder()
{
  QModelIndexList m_list = view->selectionModel()->selectedRows();
  if (m_list.size() == 1) {
    helper_addNewStation(m_list.at(0));
  } else {
    helper_addNewStation(QModelIndex());
  };
}

void stationlistModel::addNewFolderInFolder()
{
  QModelIndexList m_list = view->selectionModel()->selectedRows();
  if (m_list.size() == 1) {
    helper_addNewFolder(m_list.at(0));
  } else {
    helper_addNewFolder(QModelIndex());
  };
}

void stationlistModel::addNewStation()
{
  helper_addNewStation(QModelIndex());
}

void stationlistModel::addNewFolder()
{
  helper_addNewFolder(QModelIndex());
}

void stationlistModel::helper_deleteRadiostationobjectAndRemoveConfigfiles(stationlistItem *item)
{
  if (item->type() == stationlistItem::stream) {
    helper_deleteRadiostationobjectAndRemoveConfigfiles(item->streamObject());
  } else {
    for (int i = 0; i < item->childCount(); ++i) {
      helper_deleteRadiostationobjectAndRemoveConfigfiles(item->child(i));
    }
  };
}

void stationlistModel::helper_deleteRadiostationobjectAndRemoveConfigfiles(radioStation *station)
{
  QString m_filename = station->fullConfigFileName();
  delete station;
  // We must wait with constructing QFile until the station
  // object has been deleted (we shouldn't open a file that's yet/still open!).
  QFile theFile(m_filename);
  theFile.remove();
}

stationlistItem *stationlistModel::item(const QModelIndex & index) const
{
  if (index.isValid()) {
    return static_cast<stationlistItem *>(index.internalPointer());
  } else {
    return rootItem;
  };
}

bool stationlistModel::removeRows(int row, int count, const QModelIndex & parent)
{
  // variables
  stationlistItem *parentItem = item(parent);
  QList<stationlistItem *> itemList;

  // code
  if (count == 0) {
    return true;
  };
  // test if the values are valid (if not, QList.at() would crash!):
  if ((row >= 0) &&
      (count > 0) &&
      ((row + count - 1) < parentItem->childCount())) {
    // detach the corresponding items from the model
    itemList = helper_removeItems(parent, row, row + count - 1);
    // delete the items
    foreach (stationlistItem *item, itemList) {
      helper_deleteRadiostationobjectAndRemoveConfigfiles(item);
      delete item;
    };
    // synchronize the general config file with our internal list:
    helper_writeStationList();
    return true;
  } else {
    return false;
  };
}

void stationlistModel::writeItemToFile(stationlistItem *item, QXmlStreamWriter &file)
{
  if (item->type() == stationlistItem::stream) {
    file.writeTextElement("stream", item->streamObject()->configFileName());
  } else {
    file.writeStartElement("folder");
    file.writeAttribute("name", item->folderName());
    if (view->isExpanded(modelindexOfItem(item, 0))) {
      file.writeAttribute("expanded", "true");
    };
    for (int i = 0; i < item->childCount(); ++i) {
      writeItemToFile(item->child(i), file);
    };
    file.writeEndElement();
  };
}

inline void stationlistModel::helper_writeStationList()
{
  // variables
  KTemporaryFile tempfile;
  QXmlStreamWriter writer;

  // code
  tempfile.open();
  writer.setDevice(&tempfile);
  writer.setAutoFormatting(true);
  writer.writeStartDocument();
  writer.writeStartElement("stationlist");
  for (int i = 0; i < rootItem->childCount(); ++i) {
    writeItemToFile(rootItem->child(i), writer);
  };
  writer.writeEndElement();  // stationlist
  writer.writeEndDocument();
  tempfile.close();
  KIO::FileCopyJob *copyjob = KIO::file_move(tempfile.fileName(),
                                    helper_stationlistXmlFilepath(),
                                    -1,
                                    KIO::HideProgressInfo | KIO::Overwrite);
  KIO::NetAccess::synchronousRun(copyjob, 0);
}

void stationlistModel::record()
{
  foreach (radioStation *stream, internal_selectedStreams) {
    stream->startStreamripper();
  };
}

void stationlistModel::stopRecording()
{
  foreach (radioStation *stream, internal_selectedStreams) {
    stream->shutDown();
  };
}

void stationlistModel::showConfigDialog()
{
  QModelIndexList list = view->selectionModel()->selectedRows();
  if (list.size() == 1) {
    stationlistItem *item = static_cast<stationlistItem *>(list.at(0).internalPointer());
    if (item->type() == stationlistItem::stream) {
      item->streamObject()->showSettingsDialogWithApplyButton();
    } else {
      QPointer<folderPropertiesDialog> dialog = new folderPropertiesDialog(view);
      dialog->centralWidget->setText(item->folderName());
      int result = dialog->exec();
      // "dialog" coult be deleted during exec() by DBus or orthers - see
      // http://www.kdedevelopers.org/node/3919 for details. Therefore we use QPointer and check
      // if the object still exists.
      if (result == QDialog::Accepted && !dialog.isNull()) {
        item->setFolderName(dialog->centralWidget->text());
        reloadStreamName(item);
      };
      delete dialog;  // This is always safe, because "dialog" is a QPointer and if it was yet
      // deleted, that it was set to 0. Deleting 0 is always safe.
    };
  };
}

quint64 stationlistModel::bandwidth() const
{
  return internal_bandwidth;
}

int stationlistModel::numberOfActiveStreams() const
{
  return internal_numberOfActiveStreams;
}

void stationlistModel::rememberListOfStreamsWhichTheUserWantsToRip_ifNotYetDone()
{
  if (m_listOfStreamsOfWhichTheUserWantsThatTheyRip == 0) {
    int i;
    QList<radioStation *> m_stationlist = helper_listOfAllStreams(rootItem);
    const int m_stationlist_size = m_stationlist.size();
    m_listOfStreamsOfWhichTheUserWantsThatTheyRip = new QStringList();
    for (i=0; i < m_stationlist_size; i++) {
      if (m_stationlist.at(i)->doesTheUserWantsThatTheStreamIsRipping()) {
        m_listOfStreamsOfWhichTheUserWantsThatTheyRip->
          append(m_stationlist.at(i)->configFileName());
      };
    };
  };
}

bool stationlistModel::queryClose()
{
  // variables
  int i;

  // code
  helper_writeStationList();
  rememberListOfStreamsWhichTheUserWantsToRip_ifNotYetDone();

  // start shutdown for all processes
  if (numberOfActiveStreams() > 0) {
    QList<radioStation *> m_stationlist = helper_listOfAllStreams(rootItem);
    for (i = 0; i < m_stationlist.size(); ++i) {
      m_stationlist.at(i)->shutDown();
    };
  };

  /* Now we test a second time if there are still running streams. (This could
  have changed because we have shutted down before.) If there remain running
  streams (shutting down takes some seconds), we display a "busy" dialog until
  the shutdown is finished. */
  if (numberOfActiveStreams() > 0) {
    QPointer<KProgressDialog> m_dialog = new KProgressDialog(m_mainWidget,
      i18nc("@title:window", "Saving files..."),
      i18nc("@label", "Please wait while last files are saved..."));
    connect(this, SIGNAL(numberOfActiveStreamsIsZero()), m_dialog, SLOT(reject()));
    // min AND max = 0 means: show "busy" indicator instead of progress:
    m_dialog->progressBar()->setMinimum(0);
    m_dialog->progressBar()->setMaximum(0);
    m_dialog->setModal(true);
    m_dialog->setAutoClose(false);
    m_dialog->setMinimumDuration(0);
    // The following line hasn't any effect because of a bug in KProgressDialog.
    // Is fixed in KDE 4.2 (and maybe yet in 4.1.4).
    m_dialog->setButtonText(i18nc("@action:button", "Quit without saving"));
    m_dialog->exec();
    delete m_dialog;
  };

  return true;
}

void stationlistModel::saveProperties(KConfigGroup & m_configGroup)
{
  helper_writeStationList();
  rememberListOfStreamsWhichTheUserWantsToRip_ifNotYetDone();
  m_configGroup.writePathEntry("streamsToResume",
                                * m_listOfStreamsOfWhichTheUserWantsThatTheyRip);
  // No need to save the changes with sync() - KMainWindow and friends take care of this.
}

void stationlistModel::readProperties(const KConfigGroup & m_configGroup)
{
  // variables
  QStringList temp_stringList;
  int i;

  // code
  temp_stringList = m_configGroup.readPathEntry("streamsToResume", temp_stringList);
  QList<radioStation *> m_stationlist = helper_listOfAllStreams(rootItem);
  const int m_stationlist_size = m_stationlist.size();
  for (i = 0; i < m_stationlist_size; ++i) {
    if (temp_stringList.contains(m_stationlist.at(i)->configFileName())) {
      m_stationlist.at(i)->startStreamripper();
    };
  };
}

QList<QUrl> stationlistModel::helper_convertToUrl(const QMimeData *data)
{
  // variables
  QList<QUrl> returnValue;

  // code
  if (data->hasUrls()) {
    returnValue = data->urls();
  } else if (data->hasText()) {
    QStringList temp = data->text().split(QRegExp("\\s"), QString::SkipEmptyParts);
    foreach (const QString & singleString, temp) {
      returnValue.append(singleString);
    };
  };
  int i = 0;
  while (i < returnValue.size()) {
    if (returnValue.at(i).isValid() && (!returnValue.at(i).isEmpty())) {
      ++i;
    } else {
      returnValue.removeAt(i);
    };
  };

  return returnValue;
}

void stationlistModel::paste()
{
  dropMimeData(QApplication::clipboard()->mimeData(),
               Qt::CopyAction,
               0,
               0,
               QModelIndex());
}

void stationlistModel::pasteSelection(const QModelIndex & index)
{
  dropMimeData(QApplication::clipboard()->mimeData(QClipboard::Selection),
               Qt::CopyAction,
               index.row(),
               0,
               index.parent());
}

bool stationlistModel::dropMimeData(const QMimeData *data,
                                    Qt::DropAction action,
                                    int row,
                                    int,
                                    const QModelIndex &parent)
{
  if (action == Qt::IgnoreAction) {
    return true;
  };

  if (!(action == Qt::CopyAction)) {
    return false;
  };

  QList<QUrl> urlList = helper_convertToUrl(data);

  if (urlList.isEmpty()) {
    return false;
  } else {
    // variables
    QPointer<radioStation> m_newStation;
    QList<stationlistItem *> m_itemList;
    QModelIndex m_parent;
    QModelIndexList m_modelIndexList;

    // code
    for (int i = 0; i < urlList.size(); ++i) {
      m_newStation = new radioStation(this, m_mainWidget, QString());
      m_newStation->setServerUri(urlList.at(i));
      m_itemList.append(helper_createStreamItem(m_newStation));
    };

    if (index(row, 0, parent).isValid()) {  // QModelIndex::child() returns an invalid index,
      m_parent = index(row, 0, parent);     // so we use index() to get the child.
    } else {
      m_parent = parent;
    };
    if (!(item(m_parent)->type() == stationlistItem::folder)) {
      row = m_parent.row();
      m_parent = m_parent.parent();
    } else {
      row = item(m_parent)->childCount();
    };

    helper_insertItems(m_itemList, m_parent, row);
    foreach (stationlistItem *itemInList, m_itemList) {
      m_modelIndexList.append(modelindexOfItem(itemInList, 0));
    };
    helper_selectAndScrollTo(m_modelIndexList);
    // TODO apply sorting?
    helper_writeStationList();
    return true;
  };

  return false;  // safety fallback
}

Qt::ItemFlags stationlistModel::flags(const QModelIndex & index) const
{
  return (Qt::ItemIsDropEnabled | QAbstractItemModel::flags(index));
}

QStringList stationlistModel::mimeTypes () const
{
  QStringList value;
  value << "text/plain" << "text/uri-list";
  return value;
}

void stationlistModel::enableListeningIn()
{
  QModelIndexList actuallySelectedRows = view->selectionModel()->selectedRows();
  if (actuallySelectedRows.size() == 1) {
    stationlistItem *myItem =
      static_cast<stationlistItem *>(actuallySelectedRows.at(0).internalPointer());
    if (myItem->type() == stationlistItem::stream) {
      listen.setStation(myItem->streamObject());
      return;
    };
  };
  listen.setStation(0);
}

void stationlistModel::disableListeningIn()
{
  listen.setStation(0);
}

QModelIndex stationlistModel::parent(const QModelIndex & index) const
{
  if (!index.isValid()) {
    return QModelIndex();
  };

  stationlistItem *childItem = static_cast<stationlistItem *>(index.internalPointer());
  stationlistItem *parentItem = childItem->parent();
  if (parentItem == rootItem) {
    return QModelIndex();
  } else {
    return createIndex(parentItem->row(), 0, parentItem);
  };
}

QModelIndex stationlistModel::index(int row, int column, const QModelIndex & parent) const
{
  // variables
  stationlistItem *parentItem = item(parent);
  stationlistItem *childItem;

  // code
  if (!hasIndex(row, column, parent)) {
    return QModelIndex();
  };

  childItem = parentItem->child(row);
  if (childItem) {
    return createIndex(row, column, childItem);
  } else {
    return QModelIndex();
  };
}

bool stationlistModel::helper_hasStreams(stationlistItem *item)
{
  bool returnValue = false;
  int i = 0;
  if (item->type() == stationlistItem::folder) {
    while (!returnValue && i < item->childCount()) {
      returnValue = helper_hasStreams(item->child(i));
      ++i;
    };
  } else {
    returnValue = true;
  };
  return returnValue;
}

void stationlistModel::recalculateSelectedStreams()
{
  // variables
  const QModelIndexList indexList = view->selectionModel()->selectedRows();

  // code
  internal_selectedStreams.clear();
  foreach (const QModelIndex &index, indexList) {
    internal_selectedStreams +=
      helper_listOfAllStreams(static_cast<stationlistItem *>(index.internalPointer()));
  };
  for (int i = 0; i < internal_selectedStreams.size() - 1; ++i) {
    for (int j = i + 1; j < internal_selectedStreams.size(); ++j) {
      if (internal_selectedStreams.at(i) == internal_selectedStreams.at(j)) {
        internal_selectedStreams.removeAt(j);
      };
    };
  };
  emit selectedStreamsChanged();
}

QList<radioStation *> stationlistModel::selectedStreams() const
{
  return internal_selectedStreams;
}