← Back to branch summary

~ubuntu-branches/ubuntu/karmic/muse/karmic-proposed

« back to all changes in this revision

Viewing changes to marker/markerview.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2002-04-23 17:28:23 UTC
  • Revision ID: james.westby@ubuntu.com-20020423172823-w8yplzr81a759xa3
Tags: upstream-0.5.2
Import upstream version 0.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
marker/markerview.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//    $Id: markerview.cpp,v 1.2 2002/02/27 11:52:58 muse Exp $
 
5
//  (C) Copyright 2000 Werner Schweer (ws@seh.de)
 
6
//=========================================================
 
7
 
 
8
#include "marker.h"
 
9
#include "markerview.h"
 
10
#include "seq.h"
 
11
#include "xml.h"
 
12
#include "globals.h"
 
13
#include "icons.h"
 
14
#include "song.h"
 
15
#include "posedit.h"
 
16
 
 
17
#include <qtoolbar.h>
 
18
#include <qtoolbutton.h>
 
19
#include <qtooltip.h>
 
20
#include <qlayout.h>
 
21
#include <qsizegrip.h>
 
22
#include <qpopupmenu.h>
 
23
#include <qmenubar.h>
 
24
#include <qaction.h>
 
25
#include <qgroupbox.h>
 
26
#include <qlineedit.h>
 
27
 
 
28
enum { COL_TICK = 0, COL_SMPTE, COL_LOCK, COL_NAME };
 
29
 
 
30
//---------------------------------------------------------
 
31
//   tick
 
32
//---------------------------------------------------------
 
33
 
 
34
int MarkerItem::tick() const
 
35
      {
 
36
      return _marker->posTick();
 
37
      }
 
38
 
 
39
//---------------------------------------------------------
 
40
//   name
 
41
//---------------------------------------------------------
 
42
 
 
43
const QString MarkerItem::name() const
 
44
      {
 
45
      return _marker->name();
 
46
      }
 
47
 
 
48
//---------------------------------------------------------
 
49
//   lock
 
50
//---------------------------------------------------------
 
51
 
 
52
bool MarkerItem::lock() const
 
53
      {
 
54
      return _marker->type() == Pos::TIME;
 
55
      }
 
56
 
 
57
//---------------------------------------------------------
 
58
//   MarkerItem
 
59
//---------------------------------------------------------
 
60
 
 
61
MarkerItem::MarkerItem(QListView* parent, Marker* m)
 
62
  : QListViewItem(parent)
 
63
      {
 
64
      _marker = m;
 
65
      setText(COL_NAME, m->name());
 
66
      setTick(m->posTick());
 
67
      if (m->type() == Pos::TIME)
 
68
            setPixmap(COL_LOCK, *lockIcon);
 
69
      setLock(m->type() == Pos::TIME);
 
70
      }
 
71
 
 
72
//---------------------------------------------------------
 
73
//   setName
 
74
//---------------------------------------------------------
 
75
 
 
76
void MarkerItem::setName(const QString& s)
 
77
      {
 
78
      setText(COL_NAME, s);
 
79
      _marker = song->setMarkerName(_marker, s);
 
80
      }
 
81
 
 
82
//---------------------------------------------------------
 
83
//   setLock
 
84
//---------------------------------------------------------
 
85
 
 
86
void MarkerItem::setLock(bool lck)
 
87
      {
 
88
      setPixmap(COL_LOCK, lck ? *lockIcon : 0);
 
89
      _marker = song->setMarkerLock(_marker, lck);
 
90
      }
 
91
 
 
92
//---------------------------------------------------------
 
93
//   setTick
 
94
//---------------------------------------------------------
 
95
 
 
96
void MarkerItem::setTick(int v)
 
97
      {
 
98
      if (_marker->posTick() != v)
 
99
            _marker = song->setMarkerTick(_marker, v);
 
100
      QString s;
 
101
      int bar, beat, tick;
 
102
      sigmap.tickValues(v, &bar, &beat, &tick);
 
103
      s.sprintf("%04d.%02d.%03d", bar+1, beat+1, tick);
 
104
      setText(COL_TICK, s);
 
105
 
 
106
      double time = tempomap.tick2time(v);
 
107
      int hour = int(time) / 3600;
 
108
      int min  = (int(time) % 3600)/60;
 
109
      int sec  = int(time) % 60;
 
110
      double rest = time - (hour*3600 + min * 60 + sec);
 
111
      switch(mtcType) {
 
112
            case 0:     // 24 frames sec
 
113
                  rest *= 24;
 
114
                  break;
 
115
            case 1:     // 25
 
116
                  rest *= 25;
 
117
                  break;
 
118
            case 2:     // 30 drop frame
 
119
                  rest *= 30;
 
120
                  break;
 
121
            case 3:     // 30 non drop frame
 
122
                  rest *= 30;
 
123
                  break;
 
124
            }
 
125
      int frame = int(rest);
 
126
      int subframe = int((rest-frame)*100);
 
127
      s.sprintf("%02d:%02d:%02d:%02d:%02d",
 
128
         hour, min, sec, frame, subframe);
 
129
      setText(COL_SMPTE, s);
 
130
      }
 
131
 
 
132
//---------------------------------------------------------
 
133
//   closeEvent
 
134
//---------------------------------------------------------
 
135
 
 
136
void MarkerView::closeEvent(QCloseEvent* e)
 
137
      {
 
138
      emit deleted((int)this);
 
139
      e->accept();
 
140
      }
 
141
 
 
142
//---------------------------------------------------------
 
143
//   songChanged
 
144
//---------------------------------------------------------
 
145
 
 
146
void MarkerView::songChanged(int)
 
147
      {
 
148
      updateList();
 
149
      }
 
150
 
 
151
//---------------------------------------------------------
 
152
//   MarkerView
 
153
//---------------------------------------------------------
 
154
 
 
155
MarkerView::MarkerView(QWidget* parent)
 
156
   : TopWin(parent, "markerview", WType_TopLevel /*| WDestructiveClose*/)
 
157
      {
 
158
      setCaption("MusE: Marker");
 
159
 
 
160
      //---------Actions----------------------------
 
161
      QAction* markerAdd = new QAction("add marker",
 
162
         QIconSet(*flagIcon), "Add Marker",
 
163
        0, this, "add marker");
 
164
      connect(markerAdd, SIGNAL(activated()), SLOT(addMarker()));
 
165
 
 
166
      QAction* markerDelete = new QAction("delete marker",
 
167
         QIconSet(*deleteIcon), "Delete Marker",
 
168
         0, this, "delete marker");
 
169
      connect(markerDelete, SIGNAL(activated()), SLOT(deleteMarker()));
 
170
 
 
171
      //---------Pulldown Menu----------------------------
 
172
      QPopupMenu* fileMenu = new QPopupMenu(this);
 
173
      menuBar()->insertItem("&File", fileMenu);
 
174
      QPopupMenu* editMenu = new QPopupMenu(this);
 
175
      menuBar()->insertItem("&Edit", editMenu);
 
176
      markerAdd->addTo(editMenu);
 
177
      markerDelete->addTo(editMenu);
 
178
 
 
179
      //---------ToolBar----------------------------------
 
180
      tools = new QToolBar(this, "marker-tools");
 
181
      undoRedo->addTo(tools);
 
182
 
 
183
      QToolBar* edit = new QToolBar(this, "edit tools");
 
184
      markerAdd->addTo(edit);
 
185
      markerDelete->addTo(edit);
 
186
 
 
187
      //---------------------------------------------------
 
188
      //    master
 
189
      //---------------------------------------------------
 
190
 
 
191
      QWidget* w = new QWidget(this, "main");
 
192
      setCentralWidget(w);
 
193
      QVBoxLayout* vbox = new QVBoxLayout(w);
 
194
 
 
195
      table = new QListView(w);
 
196
      table->setAllColumnsShowFocus(true);
 
197
      table->setSelectionMode(QListView::Single);
 
198
      table->setSorting(COL_TICK, true);
 
199
 
 
200
      table->addColumn(tr("Bar:Beat:Tick"));
 
201
      table->addColumn(tr("Hr:Mn:Sc:Fr:Sf"));
 
202
      table->addColumn(tr("Lock"));
 
203
      table->addColumn(tr("Text"));
 
204
      table->setColumnWidth(3, 200);
 
205
      table->setColumnWidthMode(3, QListView::Maximum);
 
206
      connect(table, SIGNAL(selectionChanged()),
 
207
         SLOT(markerSelectionChanged()));
 
208
      connect(table, SIGNAL(clicked(QListViewItem*)),
 
209
         SLOT(clicked(QListViewItem*)));
 
210
 
 
211
      QGroupBox* props = new QGroupBox(4, Horizontal, tr("Marker Properties"), w);
 
212
 
 
213
      editTick = new PosEdit(props);
 
214
      editTick->setSizePolicy(QSizePolicy(QSizePolicy::Fixed,
 
215
         QSizePolicy::Fixed));
 
216
 
 
217
      editSMPTE = new PosEdit(props);
 
218
      editSMPTE->setSmpte(true);
 
219
      editSMPTE->setSizePolicy(QSizePolicy(QSizePolicy::Fixed,
 
220
         QSizePolicy::Fixed));
 
221
 
 
222
      lock = new QToolButton(props);
 
223
      lock->setPixmap(*lockIcon);
 
224
      lock->setToggleButton(true);
 
225
 
 
226
      editName = new QLineEdit(props);
 
227
      editName->setSizePolicy(QSizePolicy(QSizePolicy::Expanding,
 
228
         QSizePolicy::Preferred));
 
229
      connect(editName, SIGNAL(textChanged(const QString&)),
 
230
         SLOT(nameChanged(const QString&)));
 
231
      connect(editTick, SIGNAL(valueChanged(const Pos&)),
 
232
         SLOT(tickChanged(const Pos&)));
 
233
      connect(editSMPTE, SIGNAL(valueChanged(const Pos&)),
 
234
         SLOT(tickChanged(const Pos&)));
 
235
      connect(editSMPTE, SIGNAL(valueChanged(const Pos&)),
 
236
         editTick, SLOT(setValue(const Pos&)));
 
237
      connect(editTick, SIGNAL(valueChanged(const Pos&)),
 
238
         editSMPTE, SLOT(setValue(const Pos&)));
 
239
      connect(lock, SIGNAL(toggled(bool)),
 
240
         SLOT(lockChanged(bool)));
 
241
      connect(song, SIGNAL(markerChanged(int)),
 
242
         SLOT(markerChanged(int)));
 
243
 
 
244
      vbox->addWidget(table);
 
245
      vbox->addWidget(props);
 
246
 
 
247
      //---------------------------------------------------
 
248
      //    Rest
 
249
      //---------------------------------------------------
 
250
 
 
251
//      connect(song, SIGNAL(songChanged(int)), SLOT(songChanged(int)));
 
252
      updateList();
 
253
      }
 
254
 
 
255
//---------------------------------------------------------
 
256
//   MArkerView
 
257
//---------------------------------------------------------
 
258
 
 
259
MarkerView::~MarkerView()
 
260
      {
 
261
      undoRedo->removeFrom(tools);
 
262
      }
 
263
 
 
264
//---------------------------------------------------------
 
265
//   readStatus
 
266
//---------------------------------------------------------
 
267
 
 
268
void MarkerView::readStatus(Xml& xml)
 
269
      {
 
270
      for (;;) {
 
271
            Xml::Token token = xml.parse();
 
272
            const QString& tag = xml.s1();
 
273
            if (token == Xml::Error || token == Xml::End)
 
274
                  break;
 
275
            switch (token) {
 
276
                  case Xml::TagStart:
 
277
                        xml.unknown("Marker");
 
278
                        break;
 
279
                  case Xml::TagEnd:
 
280
                        if (tag == "marker")
 
281
                              return;
 
282
                  default:
 
283
                        break;
 
284
                  }
 
285
            }
 
286
      }
 
287
 
 
288
//---------------------------------------------------------
 
289
//   writeStatus
 
290
//---------------------------------------------------------
 
291
 
 
292
void MarkerView::writeStatus(int level, Xml& xml) const
 
293
      {
 
294
      xml.tag(level++, "marker");
 
295
      xml.tag(level, "/marker");
 
296
      }
 
297
 
 
298
//---------------------------------------------------------
 
299
//   addMarker
 
300
//---------------------------------------------------------
 
301
 
 
302
void MarkerView::addMarker()
 
303
      {
 
304
      Marker* m = song->addMarker(QString(""), song->cpos(), false);
 
305
      MarkerItem* newItem = new MarkerItem(table, m);
 
306
      table->setSelected(newItem, true);
 
307
      }
 
308
 
 
309
//---------------------------------------------------------
 
310
//   deleteMarker
 
311
//---------------------------------------------------------
 
312
 
 
313
void MarkerView::deleteMarker()
 
314
      {
 
315
      MarkerItem* item = (MarkerItem*)table->selectedItem();
 
316
      if (item) {
 
317
            song->removeMarker(item->marker());
 
318
            delete item;
 
319
            }
 
320
      }
 
321
 
 
322
//---------------------------------------------------------
 
323
//   updateList
 
324
//---------------------------------------------------------
 
325
 
 
326
void MarkerView::updateList()
 
327
      {
 
328
      table->clear();
 
329
      MarkerList* marker = song->marker();
 
330
      for (iMarker i = marker->begin(); i != marker->end(); ++i) {
 
331
            Marker* m = &i->second;
 
332
            QString tick;
 
333
            tick.setNum(i->first);
 
334
            new MarkerItem(table, m);
 
335
            }
 
336
      }
 
337
 
 
338
//---------------------------------------------------------
 
339
//   markerSelected
 
340
//---------------------------------------------------------
 
341
 
 
342
void MarkerView::markerSelectionChanged()
 
343
      {
 
344
      MarkerItem* item = (MarkerItem*)table->selectedItem();
 
345
      if (item == 0) {  // never triggered
 
346
            editTick->setValue(0);
 
347
            editSMPTE->setValue(0);
 
348
            editName->setText(QString(""));
 
349
            lock->setOn(false);
 
350
            editSMPTE->setEnabled(false);
 
351
            editTick->setEnabled(false);
 
352
            lock->setEnabled(false);
 
353
            editName->setEnabled(false);
 
354
            }
 
355
      else {
 
356
            editTick->setValue(item->tick());
 
357
            editSMPTE->setValue(item->tick());
 
358
            editName->setText(item->name());
 
359
            editName->setEnabled(true);
 
360
            lock->setOn(item->lock());
 
361
            lock->setEnabled(true);
 
362
            editSMPTE->setEnabled(item->lock());
 
363
            editTick->setEnabled(!item->lock());
 
364
            }
 
365
      }
 
366
 
 
367
void MarkerView::clicked(QListViewItem* i)
 
368
      {
 
369
      MarkerItem* item = (MarkerItem*)i;
 
370
      if (item == 0) {
 
371
            table->clearSelection();
 
372
            return;
 
373
            }
 
374
      song->setPos(0, item->tick(), true, true, false);
 
375
      }
 
376
 
 
377
//---------------------------------------------------------
 
378
//   nameChanged
 
379
//---------------------------------------------------------
 
380
 
 
381
void MarkerView::nameChanged(const QString& s)
 
382
      {
 
383
      MarkerItem* item = (MarkerItem*)table->selectedItem();
 
384
      if (item)
 
385
            item->setName(s);
 
386
      }
 
387
 
 
388
//---------------------------------------------------------
 
389
//   tickChanged
 
390
//---------------------------------------------------------
 
391
 
 
392
void MarkerView::tickChanged(const Pos& pos)
 
393
      {
 
394
      MarkerItem* item = (MarkerItem*)table->selectedItem();
 
395
      if (item) {
 
396
            item->setTick(pos.posTick());
 
397
            song->setPos(0, pos.posTick(), true, true, false);
 
398
            table->sort();
 
399
            }
 
400
      }
 
401
 
 
402
//---------------------------------------------------------
 
403
//   lockChanged
 
404
//---------------------------------------------------------
 
405
 
 
406
void MarkerView::lockChanged(bool lck)
 
407
      {
 
408
      MarkerItem* item = (MarkerItem*)table->selectedItem();
 
409
      if (item)
 
410
            item->setLock(lck);
 
411
      editSMPTE->setEnabled(item->lock());
 
412
      editTick->setEnabled(!item->lock());
 
413
      }
 
414
 
 
415
//---------------------------------------------------------
 
416
//   posChanged
 
417
//    select appropriate Marker
 
418
//---------------------------------------------------------
 
419
 
 
420
void MarkerView::markerChanged(int val)
 
421
      {
 
422
      if (val != Song::MARKER_CUR)
 
423
            return;
 
424
      MarkerList* marker = song->marker();
 
425
      for (iMarker i = marker->begin(); i != marker->end(); ++i) {
 
426
            if (i->second.current()) {
 
427
                  MarkerItem* item = (MarkerItem*)table->firstChild();
 
428
                  while (item) {
 
429
                        if (item->marker() == &i->second) {
 
430
                              table->setSelected(item, true);
 
431
                              return;
 
432
                              }
 
433
                        item = (MarkerItem*)item->nextSibling();
 
434
                        }
 
435
                  }
 
436
            }
 
437
      }
 
438