~ubuntu-branches/ubuntu/quantal/muse/quantal : revision 30

1

//=========================================================

2

// MusE

3

// Linux Music Editor

4

// $Id: editevent.cpp,v 1.12.2.6 2009/02/02 21:38:00 terminator356 Exp $

5

6

//

7

// This program is free software; you can redistribute it and/or

8

// modify it under the terms of the GNU General Public License

9

// as published by the Free Software Foundation; version 2 of

10

// the License, or (at your option) any later version.

11

//

12

// This program is distributed in the hope that it will be useful,

13

// but WITHOUT ANY WARRANTY; without even the implied warranty of

14

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15

// GNU General Public License for more details.

16

//

17

// You should have received a copy of the GNU General Public License

18

// along with this program; if not, write to the Free Software

19

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

20

//

21

//=========================================================

22

23

#include <stdio.h>

24

25

#include <QBoxLayout>

26

#include <QHBoxLayout>

27

#include <QGridLayout>

28

#include <QLabel>

29

#include <QListWidget>

30

//#include <QMenu>

31

#include <QMessageBox>

32

#include <QPushButton>

33

#include <QRadioButton>

34

#include <QSlider>

35

#include <QSpinBox>

36

#include <QTextEdit>

37

#include <QVBoxLayout>

38

39

#include "awl/posedit.h"

40

41

#include "song.h"

42

#include "event.h"

43

#include "midictrl.h"

44

#include "editevent.h"

45

#include "pitchedit.h"

46

#include "intlabel.h"

47

#include "globals.h"

48

///#include "posedit.h"

49

#include "gconfig.h"

50

#include "midiport.h"

51

#include "midiedit/drummap.h"

52

#include "instruments/minstrument.h"

53

#include "midi.h"

54

#include "popupmenu.h"

55

56

namespace MusEGui {

57

58

//---------------------------------------------------------

59

// string2qhex

60

//---------------------------------------------------------

61

62

QString string2hex(const unsigned char* data, int len)

63

{

64

QString d;

65

QString s;

66

for (int i = 0; i < len; ++i) {

67

if ((i > 0) && ((i % 8)==0)) {

68

d += "\n";

69

}

70

else if (i)

71

d += " ";

72

d += s.sprintf("%02x", data[i]);

73

}

74

return d;

75

}

76

77

//---------------------------------------------------------

78

// hex2string

79

//---------------------------------------------------------

80

81

char* hex2string(QWidget* parent, const char* src, int& len)

82

{

83

char buffer[2048];

84

char* dst = buffer;

85

86

while (*src) {

87

while (*src == ' ' || *src == '\n')

88

++src;

89

char* ep;

90

long val = strtol(src, &ep, 16);

91

if (ep == src) {

92

QMessageBox::information(parent,

93

QString("MusE"),

94

QWidget::tr("Cannot convert sysex string"));

95

return 0;

96

}

97

src = ep;

98

*dst++ = val;

99

if (dst - buffer >= 2048) {

100

QMessageBox::information(parent,

101

QString("MusE"),

102

QWidget::tr("Hex String too long (2048 bytes limit)"));

103

return 0;

104

}

105

}

106

len = dst - buffer;

107

if(len == 0)

108

return 0;

109

char* b = new char[len+1];

110

memcpy(b, buffer, len);

111

b[len] = 0;

112

return b;

113

}

114

115

//---------------------------------------------------------

116

// getEvent

117

//---------------------------------------------------------

118

119

MusECore::Event EditNoteDialog::getEvent(int tick, const MusECore::Event& event, QWidget* parent)

120

{

121

EditNoteDialog* dlg = new EditNoteDialog(tick, event, parent);

122

MusECore::Event nevent;

123

if (dlg->exec() == QDialog::Accepted) {

124

nevent = dlg->event();

125

}

126

delete dlg;

127

return nevent;

128

}

129

130

MusECore::Event EditSysexDialog::getEvent(int tick, const MusECore::Event& event, QWidget* parent)

131

{

132

EditSysexDialog* dlg = new EditSysexDialog(tick, event, parent);

133

MusECore::Event nevent;

134

if (dlg->exec() == QDialog::Accepted) {

135

nevent = dlg->event();

136

}

137

delete dlg;

138

return nevent;

139

}

140

141

MusECore::Event EditMetaDialog::getEvent(int tick, const MusECore::Event& event, QWidget* parent)

142

{

143

EditEventDialog* dlg = new EditMetaDialog(tick, event, parent);

144

MusECore::Event nevent;

145

if (dlg->exec() == QDialog::Accepted) {

146

nevent = dlg->event();

147

}

148

delete dlg;

149

return nevent;

150

}

151

152

MusECore::Event EditCAfterDialog::getEvent(int tick, const MusECore::Event& event, QWidget* parent)

153

{

154

EditEventDialog* dlg = new EditCAfterDialog(tick, event, parent);

155

MusECore::Event nevent;

156

if (dlg->exec() == QDialog::Accepted) {

157

nevent = dlg->event();

158

}

159

delete dlg;

160

return nevent;

161

}

162

163

MusECore::Event EditPAfterDialog::getEvent(int tick, const MusECore::Event& event, QWidget* parent)

164

{

165

EditEventDialog* dlg = new EditPAfterDialog(tick, event, parent);

166

MusECore::Event nevent;

167

if (dlg->exec() == QDialog::Accepted) {

168

nevent = dlg->event();

169

}

170

delete dlg;

171

return nevent;

172

}

173

174

//---------------------------------------------------------

175

// EditEventDialog

176

//---------------------------------------------------------

177

178

EditEventDialog::EditEventDialog(QWidget* parent)

179

: QDialog(parent)

180

{

181

QVBoxLayout* xlayout = new QVBoxLayout;

182

layout1 = new QGridLayout; // ddskrjo this

183

xlayout->addLayout(layout1);

184

185

//---------------------------------------------------

186

// Ok, Cancel

187

//---------------------------------------------------

188

189

QBoxLayout* w5 = new QHBoxLayout; // ddskrjo this

190

QPushButton* okB = new QPushButton(tr("Ok"));

191

okB->setDefault(true);

192

QPushButton* cancelB = new QPushButton(tr("Cancel"));

193

okB->setFixedWidth(80);

194

cancelB->setFixedWidth(80);

195

w5->addWidget(okB);

196

w5->addSpacing(12);

197

w5->addWidget(cancelB);

198

w5->addStretch(1);

199

xlayout->addLayout(w5);

200

setLayout(xlayout);

201

connect(cancelB, SIGNAL(clicked()), SLOT(reject()));

202

connect(okB, SIGNAL(clicked()), SLOT(accept()));

203

}

204

205

//---------------------------------------------------------

206

// EditNoteDialog

207

//---------------------------------------------------------

208

209

EditNoteDialog::EditNoteDialog(int tick, const MusECore::Event& event,

210

QWidget* parent)

211

: QDialog(parent)

212

{

213

setupUi(this);

214

if (!event.empty()) {

215

epos->setValue(tick);

216

il1->setValue(event.lenTick());

217

pl->setValue(event.pitch());

218

il2->setValue(event.velo());

219

il3->setValue(event.veloOff());

220

}

221

else {

222

epos->setValue(tick);

223

il1->setValue(96);

224

pl->setValue(64);

225

il2->setValue(100);

226

il3->setValue(0);

227

}

228

}

229

230

//---------------------------------------------------------

231

// EditNoteDialog::event

232

//---------------------------------------------------------

233

234

MusECore::Event EditNoteDialog::event()

235

{

236

MusECore::Event event(MusECore::Note);

237

event.setTick(epos->pos().tick());

238

event.setA(pl->value());

239

event.setB(il2->value());

240

event.setC(il3->value());

241

event.setLenTick(il1->value());

242

return event;

243

}

244

245

//---------------------------------------------------------

246

// EditSysExDialog

247

//---------------------------------------------------------

248

249

EditSysexDialog::EditSysexDialog(int tick, const MusECore::Event& event,

250

QWidget* parent)

251

: QDialog(parent)

252

{

253

setupUi(this);

254

sysex = 0;

255

if (!event.empty()) {

256

epos->setValue(tick);

257

edit->setText(string2hex(event.data(), event.dataLen()));

258

}

259

else {

260

epos->setValue(tick);

261

}

262

}

263

264

//---------------------------------------------------------

265

// ~EditSysexDialog

266

//---------------------------------------------------------

267

268

EditSysexDialog::~EditSysexDialog()

269

{

270

if (sysex)

271

delete sysex;

272

}

273

274

//---------------------------------------------------------

275

// EditSysExDialog::event

276

//---------------------------------------------------------

277

278

MusECore::Event EditSysexDialog::event()

279

{

280

MusECore::Event event(MusECore::Sysex);

281

event.setTick(epos->pos().tick());

282

event.setData(sysex, len);

283

return event;

284

}

285

286

//---------------------------------------------------------

287

// accept

288

//---------------------------------------------------------

289

290

void EditSysexDialog::accept()

291

{

292

QString qsrc = edit->toPlainText();

293

QByteArray ba = qsrc.toLatin1();

294

const char* src = ba.constData();

295

296

sysex = (unsigned char*)hex2string(this, src, len);

297

if (sysex)

298

QDialog::accept();

299

}

300

301

//---------------------------------------------------------

302

// EditMetaDialog

303

//---------------------------------------------------------

304

305

EditMetaDialog::EditMetaDialog(int tick, const MusECore::Event& ev,

306

QWidget* parent)

307

: EditEventDialog(parent)

308

{

309

meta = 0;

310

setWindowTitle(tr("MusE: Enter Meta Event"));

311

312

QLabel* l1 = new QLabel(tr("Time Position"));

313

///epos = new PosEdit;

314

epos = new Awl::PosEdit;

315

316

QLabel* l2 = new QLabel(tr("Meta Type"));

317

il2 = new MusEGui::IntLabel(-1, 0, 127, this, -1);

318

il2->setFixedWidth(100);

319

il2->setFrame(true);

320

il2->setDark();

321

typeLabel = new QLabel;

322

typeLabel->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);

323

QHBoxLayout* typeLayout = new QHBoxLayout;

324

typeLayout->addWidget(il2);

325

typeLayout->addWidget(typeLabel);

326

typeLayout->addStretch();

327

328

hexButton = new QRadioButton(tr("Enter Hex"));

329

hexButton->setChecked(true);

330

connect(hexButton, SIGNAL(toggled(bool)), SLOT(toggled(bool)));

331

332

edit = new QTextEdit;

333

edit->setFont(MusEGlobal::config.fonts[0]);

334

335

if (!ev.empty()) {

336

epos->setValue(tick);

337

il2->setValue(ev.dataA());

338

toggled(true);

339

edit->setText(string2hex(ev.data(), ev.dataLen()));

340

}

341

else {

342

epos->setValue(tick);

343

il2->setValue(0);

344

}

345

346

typeChanged(il2->value());

347

connect(il2, SIGNAL(valueChanged(int)), SLOT(typeChanged(int)));

348

349

layout1->addWidget(l1, 0, 0);

350

layout1->addWidget(epos, 0, 1, Qt::AlignLeft);

351

layout1->addWidget(l2, 1, 0);

352

353

//layout1->addWidget(il2, 1, 1, AlignLeft);

354

layout1->addLayout(typeLayout, 1, 1);

355

356

//layout1->addMultiCellWidget(hexButton, 2, 2, 0, 1);

357

//layout1->addMultiCellWidget(edit, 3, 3, 0, 1);

358

layout1->addWidget(hexButton, 2, 0, 1, 2);

359

layout1->addWidget(edit, 3, 0, 1, 2);

360

}

361

362

//---------------------------------------------------------

363

// typeChanged

364

//---------------------------------------------------------

365

366

void EditMetaDialog::typeChanged(int val)

367

{

368

typeLabel->setText(MusECore::midiMetaName(val));

369

}

370

371

//---------------------------------------------------------

372

// toggled

373

//---------------------------------------------------------

374

375

void EditMetaDialog::toggled(bool flag)

376

{

377

QString qsrc = edit->toPlainText();

378

QByteArray ba = qsrc.toLatin1();

379

const char* src = ba.constData();

380

edit->clear();

381

382

QString dst;

383

if (flag) { // convert to hex

384

dst = string2hex((unsigned char*)src, strlen(src));

385

}

386

else { // convert to string

387

int len;

388

dst = hex2string(this, src, len);

389

}

390

edit->setText(dst);

391

}

392

393

//---------------------------------------------------------

394

// ~EditMetaDialog

395

//---------------------------------------------------------

396

397

EditMetaDialog::~EditMetaDialog()

398

{

399

if (meta)

400

delete meta;

401

}

402

403

//---------------------------------------------------------

404

// EditMetaDialog::event

405

//---------------------------------------------------------

406

407

MusECore::Event EditMetaDialog::event()

408

{

409

MusECore::Event event(MusECore::Meta);

410

event.setTick(epos->pos().tick());

411

event.setA(il2->value());

412

event.setData(meta, len); // TODO ??

413

return event;

414

}

415

416

//---------------------------------------------------------

417

// accept

418

//---------------------------------------------------------

419

420

void EditMetaDialog::accept()

421

{

422

QString qsrc = edit->toPlainText();

423

QByteArray ba = qsrc.toLatin1();

424

const char* src = ba.constData();

425

if (!hexButton->isChecked()) {

426

meta = (unsigned char*)strdup(src);

427

len = strlen(src);

428

QDialog::accept();

429

return;

430

}

431

432

meta = (unsigned char*)hex2string(this, src, len);

433

if (meta)

434

QDialog::accept();

435

}

436

437

//---------------------------------------------------------

438

// EditCAfterDialog

439

//---------------------------------------------------------

440

441

EditCAfterDialog::EditCAfterDialog(int tick, const MusECore::Event& event,

442

QWidget* parent)

443

: EditEventDialog(parent)

444

{

445

setWindowTitle(tr("MusE: Enter Channel Aftertouch"));

446

447

QLabel* l1 = new QLabel(tr("Time Position"));

448

///epos = new PosEdit;

449

epos = new Awl::PosEdit;

450

451

QLabel* l2 = new QLabel(tr("Pressure"));

452

il2 = new MusEGui::IntLabel(-1, 0, 127, this, -1);

453

il2->setFrame(true);

454

il2->setDark();

455

456

QSlider* slider = new QSlider(Qt::Horizontal);

457

slider->setMinimum(0);

458

slider->setMaximum(127);

459

slider->setPageStep(1);

460

slider->setValue(0);

461

462

connect(slider, SIGNAL(valueChanged(int)), il2, SLOT(setValue(int)));

463

connect(il2, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));

464

465

if (!event.empty()) {

466

epos->setValue(tick);

467

il2->setValue(event.dataA());

468

slider->setValue(event.dataA());

469

}

470

else {

471

epos->setValue(tick);

472

il2->setValue(64);

473

slider->setValue(64);

474

}

475

476

layout1->addWidget(l1, 0, 0);

477

layout1->addWidget(epos, 0, 1, Qt::AlignLeft);

478

layout1->addWidget(l2, 1, 0);

479

layout1->addWidget(il2, 1, 1, Qt::AlignLeft);

480

//layout1->addMultiCellWidget(slider, 2, 2, 0, 1);

481

layout1->addWidget(slider, 2, 0, 1, 2);

482

}

483

484

//---------------------------------------------------------

485

// EditCAfterDialog::event

486

//---------------------------------------------------------

487

488

MusECore::Event EditCAfterDialog::event()

489

{

490

MusECore::Event event(MusECore::CAfter);

491

event.setTick(epos->pos().tick());

492

event.setA(il2->value());

493

return event;

494

}

495

496

//---------------------------------------------------------

497

// EditPAfterDialog

498

//---------------------------------------------------------

499

500

EditPAfterDialog::EditPAfterDialog(int tick, const MusECore::Event& event,

501

QWidget* parent)

502

: EditEventDialog(parent)

503

{

504

setWindowTitle(tr("MusE: Enter Poly Aftertouch"));

505

506

QLabel* l1 = new QLabel(tr("Time Position"));

507

///epos = new PosEdit;

508

epos = new Awl::PosEdit;

509

510

QLabel* l2 = new QLabel(tr("Pitch"));

511

pl = new MusEGui::PitchEdit;

512

QLabel* l3 = new QLabel(tr("Pressure"));

513

il2 = new MusEGui::IntLabel(-1, 0, 127, this, -1);

514

il2->setFrame(true);

515

il2->setDark();

516

517

QSlider* slider = new QSlider(Qt::Horizontal);

518

slider->setMinimum(0);

519

slider->setMaximum(127);

520

slider->setPageStep(1);

521

slider->setValue(0);

522

523

connect(slider, SIGNAL(valueChanged(int)), il2, SLOT(setValue(int)));

524

connect(il2, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));

525

526

if (!event.empty()) {

527

epos->setValue(tick);

528

pl->setValue(event.pitch());

529

il2->setValue(event.dataB());

530

slider->setValue(event.dataB());

531

}

532

else {

533

epos->setValue(tick);

534

pl->setValue(64);

535

il2->setValue(64);

536

slider->setValue(64);

537

}

538

539

layout1->addWidget(l1, 0, 0);

540

layout1->addWidget(epos, 0, 1, Qt::AlignLeft);

541

layout1->addWidget(l2, 1, 0);

542

layout1->addWidget(pl, 1, 1, Qt::AlignLeft);

543

layout1->addWidget(l3, 2, 0);

544

layout1->addWidget(il2, 2, 1, Qt::AlignLeft);

545

//layout1->addMultiCellWidget(slider, 3, 3, 0, 1);

546

layout1->addWidget(slider, 3, 0, 1, 2);

547

}

548

549

//---------------------------------------------------------

550

// EditPAfterDialog::event

551

//---------------------------------------------------------

552

553

MusECore::Event EditPAfterDialog::event()

554

{

555

MusECore::Event event(MusECore::PAfter);

556

event.setTick(epos->pos().tick());

557

event.setA(pl->value());

558

event.setB(il2->value());

559

return event;

560

}

561

//---------------------------------------------------------

562

// getEvent

563

//---------------------------------------------------------

564

565

MusECore::Event EditCtrlDialog::getEvent(int tick, const MusECore::Event& event,

566

const MusECore::MidiPart* part, QWidget* parent)

567

{

568

EditCtrlDialog* dlg = new EditCtrlDialog(tick, event, part, parent);

569

MusECore::Event nevent;

570

if (dlg->exec() == QDialog::Accepted) {

571

nevent = dlg->event();

572

}

573

delete dlg;

574

return nevent;

575

}

576

577

//---------------------------------------------------------

578

// EditCtrlDialog::event

579

//---------------------------------------------------------

580

581

MusECore::Event EditCtrlDialog::event()

582

{

583

MusECore::Event event(MusECore::Controller);

584

event.setTick(timePos->pos().tick());

585

event.setA(num);

586

if (num == MusECore::CTRL_PROGRAM)

587

event.setB(val);

588

else

589

event.setB(valSlider->value() + MusEGlobal::midiPorts[part->track()->outPort()].midiController(num)->bias());

590

return event;

591

}

592

593

//---------------------------------------------------------

594

// EditCtrlDialog

595

// PosEdit* timePos;

596

// QSlider* valSlider;

597

// QSpinBox* valSpinBox;

598

// QLabel* controllerName;

599

// QListWidget* ctrlList;

600

// QPushButton* buttonNewController;

601

//---------------------------------------------------------

602

603

EditCtrlDialog::EditCtrlDialog(int tick, const MusECore::Event& event,

604

const MusECore::MidiPart* p, QWidget* parent)

605

: QDialog(parent), part(p)

606

{

607

setupUi(this);

608

widgetStack->setAutoFillBackground(true);

609

val = 0;

610

num = 0;

611

if (!event.empty()) {

612

num = event.dataA();

613

val = event.dataB();

614

}

615

616

///pop = new QMenu(this);

617

//pop->setCheckable(false);//not necessary in Qt4

618

619

MusECore::MidiTrack* track = part->track();

620

int portn = track->outPort();

621

MusECore::MidiPort* port = &MusEGlobal::midiPorts[portn];

622

bool isDrum = track->type() == MusECore::Track::DRUM;

623

MusECore::MidiCtrlValListList* cll = port->controller();

624

625

ctrlList->clear();

626

ctrlList->setSelectionMode(QAbstractItemView::SingleSelection);

627

628

//

629

// populate list of available controller

630

//

631

632

std::list<QString> sList;

633

typedef std::list<QString>::iterator isList;

634

635

for (MusECore::iMidiCtrlValList i = cll->begin(); i != cll->end(); ++i) {

636

MusECore::MidiCtrlValList* cl = i->second;

637

int num = cl->num();

638

639

// dont show drum specific controller if not a drum track

640

if ((num & 0xff) == 0xff) {

641

if (!isDrum)

642

continue;

643

}

644

MusECore::MidiController* c = port->midiController(num);

645

isList i = sList.begin();

646

for (; i != sList.end(); ++i) {

647

if (*i == c->name())

648

break;

649

}

650

if (i == sList.end())

651

sList.push_back(c->name());

652

}

653

MusECore::MidiController* mc = port->midiController(num);

654

int idx = 0;

655

int selectionIndex = 0;

656

for (isList i = sList.begin(); i != sList.end(); ++i, ++idx) {

657

ctrlList->addItem(*i);

658

if (mc->name() == *i)

659

selectionIndex = idx;

660

}

661

ctrlList->item(selectionIndex)->setSelected(true);

662

663

valSlider->setRange(mc->minVal(), mc->maxVal());

664

valSpinBox->setRange(mc->minVal(), mc->maxVal());

665

666

controllerName->setText(mc->name());

667

668

if(!event.empty())

669

{

670

if(num == MusECore::CTRL_PROGRAM)

671

{

672

widgetStack->setCurrentIndex(1);

673

updatePatch();

674

}

675

else

676

{

677

widgetStack->setCurrentIndex(0);

678

valSlider->setValue(val - mc->bias());

679

}

680

}

681

else

682

ctrlListClicked(ctrlList->selectedItems()[0]);

683

connect(ctrlList, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(ctrlListClicked(QListWidgetItem*)));

684

connect(buttonNewController, SIGNAL(clicked()), SLOT(newController()));

685

connect(hbank, SIGNAL(valueChanged(int)), SLOT(programChanged()));

686

connect(lbank, SIGNAL(valueChanged(int)), SLOT(programChanged()));

687

connect(program, SIGNAL(valueChanged(int)), SLOT(programChanged()));

688

connect(patchName, SIGNAL(released()), SLOT(instrPopup()));

689

connect(buttonCancel, SIGNAL(clicked()), SLOT(reject()));

690

connect(buttonOk, SIGNAL(clicked()), SLOT(accept()));

691

timePos->setValue(tick);

692

693

}

694

//---------------------------------------------------------

695

// newController

696

//---------------------------------------------------------

697

698

void EditCtrlDialog::newController()

699

{

700

//QMenu* pup = new QMenu(this);

701

MusEGui::PopupMenu* pup = new MusEGui::PopupMenu(this);

702

//pup->setCheckable(this);//not necessary in Qt4

703

//

704

// populate popup with all controllers available for

705

// current instrument

706

//

707

MusECore::MidiTrack* track = part->track();

708

int portn = track->outPort();

709

MusECore::MidiPort* port = &MusEGlobal::midiPorts[portn];

710

MusECore::MidiInstrument* instr = port->instrument();

711

MusECore::MidiControllerList* mcl = instr->controller();

712

713

MusECore::MidiCtrlValListList* cll = port->controller();

714

int channel = track->outChannel();

715

int nn = 0;

716

for (MusECore::iMidiController ci = mcl->begin(); ci != mcl->end(); ++ci)

717

{

718

if(cll->find(channel, ci->second->num()) == cll->end())

719

{

720

QAction* act = pup->addAction(ci->second->name());

721

act->setData(nn);

722

++nn;

723

}

724

}

725

QAction* rv = pup->exec(buttonNewController->mapToGlobal(QPoint(0,0)));

726

if (rv) {

727

QString s = rv->text();

728

for (MusECore::iMidiController ci = mcl->begin(); ci != mcl->end(); ++ci) {

729

MusECore::MidiController* mc = ci->second;

730

if (mc->name() == s) {

731

if(cll->find(channel, mc->num()) == cll->end())

732

{

733

MusECore::MidiCtrlValList* vl = new MusECore::MidiCtrlValList(mc->num());

734

cll->add(channel, vl);

735

//MusEGlobal::song->update(SC_MIDI_CONTROLLER_ADD);

736

}

737

//for (int idx = 0; ;++idx) {

738

int idx = 0;

739

for (; idx < ctrlList->count() ;++idx) { // p4.0.25 Fix segfault

740

QString str = ctrlList->item(idx)->text();

741

if (s == str)

742

{

743

ctrlList->item(idx)->setSelected(true);

744

ctrlListClicked(ctrlList->item(idx));

745

break;

746

}

747

//if (str.isNull()) {

748

// ctrlList->addItem(s);

749

// ctrlList->item(idx)->setSelected(true);

750

// ctrlListClicked(ctrlList->item(idx));

751

// break;

752

// }

753

}

754

if (idx >= ctrlList->count()) { // p4.0.25 Fix segfault

755

ctrlList->addItem(s);

756

ctrlList->item(idx)->setSelected(true);

757

ctrlListClicked(ctrlList->item(idx));

758

break;

759

}

760

761

762

break;

763

}

764

}

765

}

766

delete pup;

767

}

768

//---------------------------------------------------------

769

// ctrlListClicked

770

//---------------------------------------------------------

771

772

void EditCtrlDialog::ctrlListClicked(QListWidgetItem* item)

773

{

774

if (item == 0)

775

return;

776

QString s(item->text());

777

778

MusECore::MidiTrack* track = part->track();

779

int portn = track->outPort();

780

MusECore::MidiPort* port = &MusEGlobal::midiPorts[portn];

781

MusECore::MidiCtrlValListList* cll = port->controller();

782

783

MusECore::iMidiCtrlValList i;

784

for (i = cll->begin(); i != cll->end(); ++i) {

785

MusECore::MidiCtrlValList* cl = i->second;

786

num = cl->num();

787

MusECore::MidiController* c = port->midiController(num);

788

if (s == c->name()) {

789

if (num == MusECore::CTRL_PROGRAM) {

790

widgetStack->setCurrentIndex(1);

791

792

val = c->initVal();

793

if(val == MusECore::CTRL_VAL_UNKNOWN)

794

val = 0;

795

updatePatch();

796

}

797

else {

798

widgetStack->setCurrentIndex(0);

799

valSlider->setRange(c->minVal(), c->maxVal());

800

valSpinBox->setRange(c->minVal(), c->maxVal());

801

controllerName->setText(s);

802

val = c->initVal();

803

804

if(val == MusECore::CTRL_VAL_UNKNOWN || val == 0)

805

{

806

switch(num)

807

{

808

case MusECore::CTRL_PANPOT:

809

val = 64 - c->bias();

810

break;

811

case MusECore::CTRL_VOLUME:

812

val = 100;

813

break;

814

default:

815

val = 0;

816

break;

817

}

818

}

819

valSlider->setValue(val);

820

}

821

break;

822

}

823

}

824

if (i == cll->end())

825

printf("controller %s not found!\n", s.toLatin1().constData());

826

}

827

828

//---------------------------------------------------------

829

// updatePatch

830

//---------------------------------------------------------

831

832

void EditCtrlDialog::updatePatch()

833

{

834

MusECore::MidiTrack* track = part->track();

835

int port = track->outPort();

836

int channel = track->outChannel();

837

MusECore::MidiInstrument* instr = MusEGlobal::midiPorts[port].instrument();

838

patchName->setText(instr->getPatchName(channel, val, MusEGlobal::song->mtype(), track->type() == MusECore::Track::DRUM));

839

840

int hb = ((val >> 16) & 0xff) + 1;

841

if (hb == 0x100)

842

hb = 0;

843

int lb = ((val >> 8) & 0xff) + 1;

844

if (lb == 0x100)

845

lb = 0;

846

int pr = (val & 0xff) + 1;

847

if (pr == 0x100)

848

pr = 0;

849

850

hbank->blockSignals(true);

851

lbank->blockSignals(true);

852

program->blockSignals(true);

853

854

hbank->setValue(hb);

855

lbank->setValue(lb);

856

program->setValue(pr);

857

858

hbank->blockSignals(false);

859

lbank->blockSignals(false);

860

program->blockSignals(false);

861

}

862

863

//---------------------------------------------------------

864

// instrPopup

865

//---------------------------------------------------------

866

867

void EditCtrlDialog::instrPopup()

868

{

869

MusECore::MidiTrack* track = part->track();

870

int channel = track->outChannel();

871

int port = track->outPort();

872

MusECore::MidiInstrument* instr = MusEGlobal::midiPorts[port].instrument();

873

874

//QMenu* pup = new QMenu(this);

875

MusEGui::PopupMenu* pup = new MusEGui::PopupMenu(this);

876

//populatePatchPopup(instr, pup, channel, MusEGlobal::song->mtype(), track->type() == MusECore::Track::DRUM);

877

instr->populatePatchPopup(pup, channel, MusEGlobal::song->mtype(), track->type() == MusECore::Track::DRUM);

878

879

if(pup->actions().count() == 0)

880

{

881

delete pup;

882

return;

883

}

884

885

QAction* rv = pup->exec(patchName->mapToGlobal(QPoint(10,5)));

886

if (rv) {

887

val = rv->data().toInt();

888

updatePatch();

889

}

890

891

delete pup;

892

}

893

894

//---------------------------------------------------------

895

// programChanged

896

//---------------------------------------------------------

897

898

void EditCtrlDialog::programChanged()

899

{

900

// MusECore::MidiTrack* track = part->track();

901

// int channel = track->outChannel();

902

// int port = track->outPort();

903

int hb = hbank->value();

904

int lb = lbank->value();

905

int prog = program->value();

906

907

if (hb > 0 && hb < 129)

908

hb -= 1;

909

else

910

hb = 0xff;

911

if (lb > 0 && lb < 129)

912

lb -= 1;

913

else

914

lb = 0xff;

915

if (prog > 0 && prog < 129)

916

prog -= 1;

917

else

918

prog = 0xff;

919

920

val = (hb << 16) + (lb << 8) + prog;

921

updatePatch();

922

}

923

924

} // namespace MusEGui