src/Model_Artwork.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
   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, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Model_Artwork.h"
  24
  25 //Internal
  26 #include "Global.h"
  27
  28 //MUtils
  29 #include <MUtils/Global.h>
  30
  31 //Qt
  32 #include <QFile>
  33 #include <QMutex>
  34 #include <QMutexLocker>
  35
  36 ////////////////////////////////////////////////////////////
  37 // Shared data class
  38 ////////////////////////////////////////////////////////////
  39
  40 class ArtworkModel_SharedData
  41 {
  42         friend ArtworkModel;
  43
  44 protected:
  45         ArtworkModel_SharedData(const QString &filePath, const bool isOwner)
  46         :
  47                 m_isOwner(isOwner),
  48                 m_filePath(filePath),
  49                 m_fileHandle(NULL)
  50         {
  51                 m_referenceCounter = 1;
  52
  53                 if(!m_filePath.isEmpty())
  54                 {
  55                         QFile *file = new QFile(m_filePath);
  56                         if(file->open(QIODevice::ReadOnly))
  57                         {
  58                                 m_fileHandle = file;
  59                         }
  60                         else
  61                         {
  62                                 qWarning("[ArtworkModel] Failed to open artwork file!");
  63                                 MUTILS_DELETE(file);
  64                         }
  65                 }
  66         }
  67
  68         ~ArtworkModel_SharedData(void)
  69         {
  70                 if(m_fileHandle)
  71                 {
  72                         if(m_isOwner)
  73                         {
  74                                 m_fileHandle->remove();
  75                         }
  76                         m_fileHandle->close();
  77                         MUTILS_DELETE(m_fileHandle);
  78                 }
  79         }
  80
  81         static ArtworkModel_SharedData *attach(ArtworkModel_SharedData *ptr)
  82         {
  83                 if(ptr)
  84                 {
  85                         QMutexLocker lock(&s_mutex);
  86                         ptr->m_referenceCounter = ptr->m_referenceCounter + 1;
  87                         return ptr;
  88                 }
  89                 return NULL;
  90         }
  91
  92         static void detach(ArtworkModel_SharedData **ptr)
  93         {
  94                 if(*ptr)
  95                 {
  96                         QMutexLocker lock(&s_mutex);
  97                         if((*ptr)->m_referenceCounter > 0)
  98                         {
  99                                 (*ptr)->m_referenceCounter = (*ptr)->m_referenceCounter - 1;
 100                                 if((*ptr)->m_referenceCounter < 1)
 101                                 {
 102                                         delete (*ptr);
 103                                 }
 104                         }
 105                         else
 106                         {
 107                                 qWarning("[ArtworkModel::detach] Ref counter already zero!");
 108                         }
 109                         *ptr = NULL;
 110                 }
 111         }
 112
 113         const QString m_filePath;
 114         const bool m_isOwner;
 115         QFile *m_fileHandle;
 116         unsigned int m_referenceCounter;
 117
 118         static QMutex s_mutex;
 119 };
 120
 121 QMutex ArtworkModel_SharedData::s_mutex;
 122
 123 ////////////////////////////////////////////////////////////
 124 // Constructor & Destructor
 125 ////////////////////////////////////////////////////////////
 126
 127 ArtworkModel::ArtworkModel(void)
 128 :
 129         m_mutex(new QMutex)
 130 {
 131         m_data = NULL;
 132 }
 133
 134 ArtworkModel::ArtworkModel(const QString &fileName, bool isOwner)
 135 :
 136         m_mutex(new QMutex)
 137 {
 138         m_data = new ArtworkModel_SharedData(fileName, isOwner);
 139 }
 140
 141 ArtworkModel::ArtworkModel(const ArtworkModel &model)
 142 :
 143         m_mutex(new QMutex)
 144 {
 145         m_data = ArtworkModel_SharedData::attach(model.m_data);
 146 }
 147
 148 ArtworkModel &ArtworkModel::operator=(const ArtworkModel &model)
 149 {
 150         QMutexLocker lock(m_mutex);
 151         if(m_data != model.m_data)
 152         {
 153                 ArtworkModel_SharedData::detach(&m_data);
 154                 m_data = ArtworkModel_SharedData::attach(model.m_data);
 155         }
 156         return (*this);
 157 }
 158
 159 ArtworkModel::~ArtworkModel(void)
 160 {
 161         QMutexLocker lock(m_mutex);
 162         ArtworkModel_SharedData::detach(&m_data);
 163         lock.unlock();
 164         MUTILS_DELETE(m_mutex);
 165 }
 166
 167 ////////////////////////////////////////////////////////////
 168 // Public Functions
 169 ////////////////////////////////////////////////////////////
 170
 171 const QString &ArtworkModel::filePath(void) const
 172 {
 173         QMutexLocker lock(m_mutex);
 174         return (m_data) ? m_data->m_filePath : m_nullString;
 175 }
 176
 177 bool ArtworkModel::isOwner(void) const
 178 {
 179         QMutexLocker lock(m_mutex);
 180         return (m_data) ? m_data->m_isOwner : false;
 181 }
 182
 183 void ArtworkModel::setFilePath(const QString &newPath, bool isOwner)
 184 {
 185         QMutexLocker lock(m_mutex);
 186         ArtworkModel_SharedData::detach(&m_data);
 187         if(!newPath.isEmpty())
 188         {
 189                 m_data = new ArtworkModel_SharedData(newPath, isOwner);
 190         }
 191 }
 192
 193 void ArtworkModel::clear(void)
 194 {
 195         QMutexLocker lock(m_mutex);
 196         ArtworkModel_SharedData::detach(&m_data);
 197 }