← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kradio/utopic

« back to all changes in this revision

Viewing changes to kradio3/src/libkradio-gui/stationselector.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Marc 'HE' Brockschmidt
  • Date: 2008-03-16 19:00:02 UTC
  • mfrom: (3.1.2 gutsy)
  • Revision ID: james.westby@ubuntu.com-20080316190002-sdjqu8cahhx7c6tk
Tags: 0.1.1.1~20061112-3.1
http://bugs.debian.org/455390
* Non-maintainer upload.
* Fix gcc-4.3 FTBFS, patch by Kibi (Closes: #455390)

Show diffs side-by-side

added added

removed removed

Lines of Context:
kradio3/src/libkradio-gui/stationselector.cpp
1
 
/***************************************************************************
2
 
                          stationselector.cpp  -  description
3
 
                             -------------------
4
 
    begin                : Son Aug 3 2003
5
 
    copyright            : (C) 2003 by Martin Witte
6
 
    email                : witte@kawo1.rwth-aachen.de
7
 
 ***************************************************************************/
8
 
 
9
 
/***************************************************************************
10
 
 *                                                                         *
11
 
 *   This program is free software; you can redistribute it and/or modify  *
12
 
 *   it under the terms of the GNU General Public License as published by  *
13
 
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 
 *   (at your option) any later version.                                   *
15
 
 *                                                                         *
16
 
 ***************************************************************************/
17
 
 
18
 
using namespace std;
19
 
 
20
 
#include <kpushbutton.h>
21
 
#include <algorithm>
22
 
 
23
 
#include "../libkradio/stationlist.h"
24
 
#include "../radio-stations/radiostation.h"
25
 
 
26
 
#include "stationselector.h"
27
 
#include "radiostation-listview.h"
28
 
 
29
 
StationSelector::StationSelector (QWidget *parent)
30
 
    : StationSelectorUI(parent),
31
 
      m_dirty(true)
32
 
{
33
 
    QObject::connect(buttonToLeft,  SIGNAL(clicked()), this, SLOT(slotButtonToLeft()));
34
 
    QObject::connect(buttonToRight, SIGNAL(clicked()), this, SLOT(slotButtonToRight()));
35
 
    QObject::connect(listAvailable, SIGNAL(sigStationsReceived(const QStringList&)), this, SLOT(slotMoveToLeft(const QStringList&)));
36
 
    QObject::connect(listSelected,  SIGNAL(sigStationsReceived(const QStringList&)), this, SLOT(slotMoveToRight(const QStringList&)));
37
 
 
38
 
    listSelected->setSelectionMode(QListView::Extended);
39
 
    listAvailable->setSelectionMode(QListView::Extended);
40
 
}
41
 
 
42
 
 
43
 
StationSelector::~StationSelector ()
44
 
{
45
 
}
46
 
 
47
 
 
48
 
bool StationSelector::connectI(Interface *i)
49
 
{
50
 
    bool a = IStationSelectionClient::connectI(i);
51
 
    bool b = IRadioClient::connectI(i);
52
 
    return a || b;
53
 
}
54
 
 
55
 
 
56
 
bool StationSelector::disconnectI(Interface *i)
57
 
{
58
 
    bool a = IStationSelectionClient::disconnectI(i);
59
 
    bool b = IRadioClient::disconnectI(i);
60
 
    return a || b;
61
 
}
62
 
 
63
 
 
64
 
bool StationSelector::noticeStationSelectionChanged(const QStringList &sl)
65
 
{
66
 
    m_stationIDsNotDisplayed.clear();
67
 
    m_stationIDsSelected.clear();
68
 
    m_stationIDsAvailable.clear();
69
 
 
70
 
    for (unsigned int i = 0; i < m_stationIDsAll.count(); ++i) {
71
 
        if (sl.contains(m_stationIDsAll[i])) {
72
 
            m_stationIDsSelected.append(m_stationIDsAll[i]);
73
 
        } else {
74
 
            m_stationIDsAvailable.append(m_stationIDsAll[i]);
75
 
        }
76
 
    }
77
 
    for (unsigned int i = 0; i < sl.count(); ++i) {
78
 
        if (!m_stationIDsAll.contains(sl[i]))
79
 
            m_stationIDsNotDisplayed.append(sl[i]);
80
 
    }
81
 
    updateListViews();
82
 
    m_dirty = false;
83
 
    return true;
84
 
}
85
 
 
86
 
 
87
 
bool StationSelector::noticeStationsChanged(const StationList &sl)
88
 
{
89
 
    slotSetDirty();
90
 
 
91
 
    listAvailable->clear();
92
 
    listSelected->clear();
93
 
 
94
 
    m_stationIDsAvailable.clear();
95
 
    m_stationIDsAll.clear();
96
 
 
97
 
    for (unsigned int i = 0; i < m_stationIDsSelected.count(); ++i)
98
 
        m_stationIDsNotDisplayed.append(m_stationIDsSelected[i]);
99
 
 
100
 
    m_stationIDsSelected.clear();
101
 
 
102
 
    for (RawStationList::Iterator i(sl.all()); i.current(); ++i) {
103
 
        const QString &id = i.current()->stationID();
104
 
 
105
 
        m_stationIDsAll.append(id);
106
 
        if (m_stationIDsNotDisplayed.contains(id)) {
107
 
            m_stationIDsNotDisplayed.remove(id);
108
 
            m_stationIDsSelected.append(id);
109
 
        } else {
110
 
            m_stationIDsAvailable.append(id);
111
 
        }
112
 
    }
113
 
 
114
 
    updateListViews();
115
 
    return true;
116
 
}
117
 
 
118
 
 
119
 
void StationSelector::slotButtonToLeft()
120
 
{
121
 
    slotSetDirty();
122
 
    listAvailable->clearSelection();
123
 
    QListViewItem *item = listSelected->firstChild();
124
 
    int idx_from = 0;
125
 
    while (item) {
126
 
        QListViewItem *next_item = item->nextSibling();
127
 
 
128
 
        if (item->isSelected()) {
129
 
 
130
 
            moveItem (listSelected,  m_stationIDsSelected,
131
 
                      item,          idx_from,
132
 
                      listAvailable, m_stationIDsAvailable);
133
 
 
134
 
            --idx_from;
135
 
        }
136
 
        item = next_item;
137
 
        ++idx_from;
138
 
    }
139
 
}
140
 
 
141
 
 
142
 
void StationSelector::slotButtonToRight()
143
 
{
144
 
    slotSetDirty();
145
 
    listSelected->clearSelection();
146
 
    QListViewItem *item = listAvailable->firstChild();
147
 
    int idx_from = 0;
148
 
    while (item) {
149
 
        QListViewItem *next_item = item->nextSibling();
150
 
 
151
 
        if (item->isSelected()) {
152
 
 
153
 
            moveItem (listAvailable, m_stationIDsAvailable,
154
 
                      item,          idx_from,
155
 
                      listSelected,  m_stationIDsSelected);
156
 
 
157
 
            --idx_from;
158
 
        }
159
 
        item = next_item;
160
 
        ++idx_from;
161
 
    }
162
 
}
163
 
 
164
 
 
165
 
void StationSelector::slotMoveToRight(const QStringList &list)
166
 
{
167
 
    slotSetDirty();
168
 
    listSelected->clearSelection();
169
 
    QListViewItem *item = listAvailable->firstChild();
170
 
    int idx_from = 0;
171
 
    while (item) {
172
 
        QListViewItem *next_item = item->nextSibling();
173
 
 
174
 
        if (list.contains(m_stationIDsAvailable[idx_from])) {
175
 
 
176
 
            moveItem (listAvailable, m_stationIDsAvailable,
177
 
                      item,          idx_from,
178
 
                      listSelected,  m_stationIDsSelected);
179
 
 
180
 
            --idx_from;
181
 
        }
182
 
        item = next_item;
183
 
        ++idx_from;
184
 
    }
185
 
}
186
 
 
187
 
 
188
 
void StationSelector::slotMoveToLeft(const QStringList &list)
189
 
{
190
 
    slotSetDirty();
191
 
    listAvailable->clearSelection();
192
 
    QListViewItem *item = listSelected->firstChild();
193
 
    int idx_from = 0;
194
 
    while (item) {
195
 
        QListViewItem *next_item = item->nextSibling();
196
 
 
197
 
        if (list.contains(m_stationIDsSelected[idx_from])) {
198
 
 
199
 
            moveItem (listSelected,  m_stationIDsSelected,
200
 
                      item,          idx_from,
201
 
                      listAvailable, m_stationIDsAvailable);
202
 
 
203
 
            --idx_from;
204
 
        }
205
 
        item = next_item;
206
 
        ++idx_from;
207
 
    }
208
 
}
209
 
 
210
 
 
211
 
void StationSelector::moveItem(
212
 
  RadioStationListView *fromListView,
213
 
  QStringList          &fromIDList,
214
 
  QListViewItem        *item,
215
 
  int                   idx_from,
216
 
  RadioStationListView *toListView,
217
 
  QStringList          &toIDList
218
 
)
219
 
{
220
 
    fromListView->takeItem(item, idx_from);
221
 
 
222
 
    QString id = fromIDList[idx_from];
223
 
    fromIDList.remove(fromIDList.at(idx_from));
224
 
 
225
 
    unsigned int  idx_to  = 0,
226
 
                  idx_all = 0;
227
 
    bool found = false;
228
 
    QListViewItem *item_to      = toListView->firstChild(),
229
 
                  *prev_item_to = NULL;
230
 
 
231
 
    while (idx_all < m_stationIDsAll.count() &&
232
 
           idx_to  < toIDList.count())
233
 
    {
234
 
        while (m_stationIDsAll[idx_all] != toIDList[idx_to])
235
 
        {
236
 
            if (m_stationIDsAll[idx_all] == id) {
237
 
                found = true;
238
 
                break;
239
 
            }
240
 
            ++idx_all;
241
 
        }
242
 
        if (found)
243
 
            break;
244
 
 
245
 
        prev_item_to = item_to;
246
 
        item_to = item_to->nextSibling();
247
 
        ++idx_to;
248
 
    }
249
 
 
250
 
    toIDList.insert(toIDList.at(idx_to), id);
251
 
    toListView->insertItem(item, id, idx_to);
252
 
    if (prev_item_to) {
253
 
        item->moveItem(prev_item_to);
254
 
    } else {
255
 
        item->moveItem(item_to);
256
 
        if (item_to) item_to->moveItem(item);
257
 
    }
258
 
}
259
 
 
260
 
 
261
 
void StationSelector::updateListViews()
262
 
{
263
 
    listAvailable->clear();
264
 
    listSelected->clear();
265
 
    const StationList &stations = queryStations();
266
 
    const RawStationList    &sl = stations.all();
267
 
 
268
 
    for (unsigned int i = 0; i < m_stationIDsAvailable.count(); ++i) {
269
 
        QString id = m_stationIDsAvailable[i];
270
 
        listAvailable->appendStation(sl.stationWithID(id), sl.idxWithID(id)+1);
271
 
    }
272
 
    for (unsigned int i = 0; i < m_stationIDsSelected.count(); ++i) {
273
 
        QString id = m_stationIDsSelected[i];
274
 
        listSelected->appendStation(sl.stationWithID(id), sl.idxWithID(id)+1);
275
 
    }
276
 
}
277
 
 
278
 
 
279
 
void StationSelector::slotOK()
280
 
{
281
 
    if (m_dirty) {
282
 
        QStringList l = m_stationIDsSelected;
283
 
        for (unsigned int i = 0; i < m_stationIDsNotDisplayed.count(); ++i)
284
 
            l.append(m_stationIDsNotDisplayed[i]);
285
 
        sendStationSelection(l);
286
 
    }
287
 
    m_dirty = false;
288
 
}
289
 
 
290
 
 
291
 
void StationSelector::slotCancel()
292
 
{
293
 
    if (m_dirty) {
294
 
        noticeStationSelectionChanged(queryStationSelection());
295
 
    }
296
 
    m_dirty = false;
297
 
}
298
 
 
299
 
 
300
 
void StationSelector::saveState (KConfig *cfg) const
301
 
{
302
 
    listSelected->saveState(cfg);
303
 
    listAvailable->saveState(cfg);
304
 
}
305
 
 
306
 
 
307
 
void StationSelector::restoreState (KConfig *cfg)
308
 
{
309
 
    listSelected->restoreState(cfg);
310
 
    listAvailable->restoreState(cfg);
311
 
}
312
 
 
313
 
void StationSelector::slotSetDirty()
314
 
{
315
 
    if (!m_dirty) {
316
 
        m_dirty = true;
317
 
        emit sigDirty();
318
 
    }
319
 
}
320
 
 
321
 
#include "stationselector.moc"