src/playlist/PlaylistAlbumGroup.cpp

   1 /***************************************************************************
   2  *   Copyright (c) 2007  Nikolaj Hald Nielsen <nhnFreespirit@gmail.com>    *
   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 2 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, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  18  ***************************************************************************/
  19
  20 #include "PlaylistAlbumGroup.h"
  21
  22 #include "debug.h"
  23
  24 namespace Playlist {
  25
  26 AlbumGroup::AlbumGroup()
  27 {
  28     //DEBUG_BLOCK
  29 }
  30
  31
  32 AlbumGroup::~AlbumGroup()
  33 {
  34     //DEBUG_BLOCK
  35 }
  36
  37 }
  38
  39 void Playlist::AlbumGroup::addRow(int row)
  40 {
  41     //DEBUG_BLOCK
  42
  43     //Does this row fit in any of our existing groups?
  44     bool inGroup = false;
  45     for ( int i = 0; i < m_groups.count(); i++ ) {
  46
  47         if ( m_groups[i].rows.contains( row ) ) {
  48             inGroup = true;
  49             break;
  50         }
  51         else if ( m_groups[i].rows.last() == row - 1 ) {
  52             m_groups[i].rows.append( row );
  53             inGroup = true;
  54             break;
  55         }
  56
  57     }
  58
  59     //no group found, create new one:
  60     if ( !inGroup ) {
  61         Group newGroup;
  62         newGroup.collapsed = false;
  63         newGroup.rows.append( row );
  64         m_groups.append( newGroup );
  65     }
  66 }
  67
  68 int Playlist::AlbumGroup::groupMode( int row )
  69 {
  70     //DEBUG_BLOCK
  71
  72     foreach( const Group &group, m_groups ) {
  73         if ( group.rows.contains( row ) ) {
  74
  75             //debug() << "row " << row << " is collapsed= " << group.collapsed;
  76
  77             if ( group.rows.count() < 2 )
  78                 return None;
  79             else if ( group.rows.first() == row ) {
  80                 if ( !group.collapsed )
  81                     return Head;
  82                 else
  83                     return Head_Collapsed;
  84             } else if ( group.rows.last() == row ) {
  85                 if ( !group.collapsed )
  86                     return End;
  87                 else
  88                 return Collapsed;
  89             } else {
  90                 if ( !group.collapsed )
  91                     return Body;
  92                 else
  93                     return Collapsed;
  94             }
  95         }
  96     }
  97
  98     return None;
  99
 100 }
 101
 102
 103 bool Playlist::AlbumGroup::alternate( int row )
 104 {
 105     if( m_groups.count() > 0) {
 106         foreach( const Group &group, m_groups ) {
 107             int index = group.rows.indexOf( row );
 108          if ( index != -1 ) {
 109                 return ( index % 2 ) == 1;
 110             }
 111         }
 112     }
 113     return false;
 114 }
 115
 116 void Playlist::AlbumGroup::setCollapsed(int row, bool collapsed)
 117 {
 118     //DEBUG_BLOCK
 119     for (int i = 0; i < m_groups.count(); i++ ) {
 120         if ( m_groups[ i ].rows.contains( row ) ) {
 121             m_groups[ i ].collapsed = collapsed;
 122             //debug() << "row " << row << " collapsed = " << m_groups[ i ].collapsed;
 123         }
 124     }
 125 }
 126
 127 int Playlist::AlbumGroup::elementsInGroup(int row)
 128 {
 129     //DEBUG_BLOCK
 130     foreach( const Group &group, m_groups ) {
 131         if ( group.rows.contains( row ) ) {
 132             return group.rows.count();
 133         }
 134     }
 135
 136     return 0;
 137 }
 138
 139
 140 int Playlist::AlbumGroup::firstInGroup(int row)
 141 {
 142
 143     foreach( const Group &group, m_groups ) {
 144         if ( group.rows.contains( row ) ) {
 145             return group.rows.first();
 146         }
 147     }
 148
 149     return -1;
 150
 151 }
 152
 153 int Playlist::AlbumGroup::lastInGroup(int row)
 154 {
 155
 156     foreach( const Group &group, m_groups ) {
 157         if ( group.rows.contains( row ) ) {
 158             return group.rows.last();
 159         }
 160     }
 161
 162     return -1;
 163 }
 164
 165 void Playlist::AlbumGroup::removeGroup(int row)
 166 {
 167
 168     for (int i = 0; i < m_groups.count(); i++ ) {
 169         if ( m_groups[ i ].rows.contains( row ) ) {
 170             m_groups.removeAt( i );
 171             return;
 172         }
 173     }
 174
 175
 176 }
 177
 178 int Playlist::AlbumGroup::subgroupCount()
 179 {
 180     return m_groups.count();
 181 }
 182
 183 void Playlist::AlbumGroup::printGroupRows()
 184 {
 185    foreach( const Group &group, m_groups ) {
 186         debug() << "Subgroup: " << group.rows;
 187   }
 188
 189 }
 190
 191 void Playlist::AlbumGroup::removeBetween(int first, int last)
 192 {
 193     DEBUG_BLOCK
 194     debug() << "first: " << first << ", last: " << last;
 195     for ( int i = first; i <= last; i++ ) {
 196         for (int j = 0; j < m_groups.count(); j++ ) {
 197             if ( m_groups[ j ].rows.contains( i ) ) {
 198                     m_groups.removeAt( j );
 199             }
 200         }
 201     }
 202
 203 }
 204
 205
 206 //when something is inserted or removed, all following indexes must be moved to match their actual new position.
 207 void Playlist::AlbumGroup::offsetBetween(int first, int last, int offset)
 208 {
 209
 210     DEBUG_BLOCK
 211     debug() << "first: " << first << ", last: " << last;
 212     for (int j = 0; j < m_groups.count(); j++ ) {
 213         for ( int i = first; i <= last; i++ ) {
 214             if ( m_groups[ j ].rows.contains( i ) ) {
 215                 //offset all in this group (so we dont break any groups)
 216                 for ( int k = 0; k < m_groups[ j ].rows.count(); k++ ) {
 217                     m_groups[ j ].rows.append( m_groups[ j ].rows.takeFirst() + offset );
 218                 }
 219                 break;
 220             }
 221         }
 222     }
 223 }
 224
 225
 226