← Back to branch summary

~ubuntu-branches/ubuntu/hoary/kdemultimedia/hoary

« back to all changes in this revision

Viewing changes to kmidi/kmidiframe.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Martin Schulze
  • Date: 2003-01-22 15:00:51 UTC
  • Revision ID: james.westby@ubuntu.com-20030122150051-uihwkdoxf15mi1tn
Tags: upstream-2.2.2
Import upstream version 2.2.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
kmidi/kmidiframe.cpp
 
1
/*
 
2
 
 
3
   kmidi - a midi to wav converter
 
4
 
 
5
   $Id: kmidiframe.cpp,v 1.10 2000/12/01 21:59:02 malte Exp $
 
6
 
 
7
   Copyright 1997, 1998 Bernd Johannes Wuebben math.cornell.edu
 
8
 
 
9
   This program is free software; you can redistribute it and/or modify
 
10
   it under the terms of the GNU General Public License as published by
 
11
   the Free Software Foundation; either version 2, or (at your option)
 
12
   any later version.
 
13
 
 
14
   This program is distributed in the hope that it will be useful,
 
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
   GNU General Public License for more details.
 
18
 
 
19
   You should have received a copy of the GNU General Public License
 
20
   along with this program; if not, write to the Free Software
 
21
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
22
 
 
23
 
 
24
 */
 
25
 
 
26
#include <stdio.h>
 
27
#include <stdlib.h>
 
28
#include <unistd.h>
 
29
#include <math.h>
 
30
 
 
31
//#include <dcopclient.h>
 
32
#include <kconfig.h>
 
33
#include <klocale.h>
 
34
//#include <kmessagebox.h>
 
35
 
 
36
#include <khelpmenu.h>
 
37
//#include <kfiledialog.h>
 
38
#include <kmidifiledlg.h>
 
39
 
 
40
#include "kmidi.h"
 
41
 
 
42
#include "kmidiframe.h"
 
43
 
 
44
 
 
45
int menubarheight = 0;
 
46
bool menubarisvisible;
 
47
 
 
48
QSize requestedframesize = QSize (0, 0);
 
49
int fixframesizecount = 0;
 
50
 
 
51
//QFont default_font("Helvetica", 10, QFont::Bold);
 
52
 
 
53
 
 
54
KMidiFrame *kmidiframe;
 
55
 
 
56
DockWidget*     dock_widget;
 
57
 
 
58
KMidiFrame::KMidiFrame( const char *name ) :
 
59
    KMainWindow( 0, name )
 
60
{
 
61
 
 
62
    menuBar = new KMenuBar(this);
 
63
 
 
64
    QPopupMenu *fileMenu = new QPopupMenu;
 
65
    menuBar->insertItem("&File", fileMenu);
 
66
 
 
67
    fileMenu->insertItem( i18n("&Open..."), this,
 
68
                        SLOT(file_Open()), CTRL+Key_O );
 
69
    fileMenu->insertSeparator();
 
70
    fileMenu->insertItem( i18n("&Quit"), this, SLOT(quitClick()), CTRL+Key_Q );
 
71
 
 
72
    kmidi = new KMidi(this, "_kmidi" );
 
73
 
 
74
    view_options = new QPopupMenu();
 
75
    CHECK_PTR( view_options );
 
76
    view_options->setCheckable( TRUE );
 
77
    menuBar->insertItem( i18n("&View"), view_options );
 
78
    connect( view_options, SIGNAL(activated(int)), this, SLOT(doViewMenuItem(int)) );
 
79
    connect( view_options, SIGNAL(aboutToShow()), this, SLOT(fixViewItems()) );
 
80
        m_on_id = view_options->insertItem(  i18n("Meter shown") );
 
81
        view_options->setWhatsThis(m_on_id, i18n("When you can see this<br>\n"
 
82
                                "menu, the channel meter<br>\n"
 
83
                                "is always turned on.") );
 
84
        m_off_id = view_options->insertItem(  i18n("Meter off") );
 
85
        view_options->setWhatsThis(m_off_id, i18n("This turns off the channel<br>\n"
 
86
                                "meter display, and also hides<br>\n"
 
87
                                "this menu bar.") );
 
88
        view_options->insertSeparator();
 
89
        i_on_id = view_options->insertItem(  i18n("Info shown") );
 
90
        view_options->setWhatsThis(i_on_id, i18n("Shows a window at the<br>\n"
 
91
                                "bottom with info about the<br>\n"
 
92
                                "midi file being played.") );
 
93
        i_off_id = view_options->insertItem(  i18n("Info off") );
 
94
        view_options->setWhatsThis(i_off_id, i18n("Turns off the info window<br>\n"
 
95
                                "at the bottom.") );
 
96
    view_level = new QPopupMenu();
 
97
    CHECK_PTR( view_level );
 
98
    view_level->setCheckable( TRUE );
 
99
    view_options->insertSeparator();
 
100
    view_options->insertItem( i18n("Info level"), view_level);
 
101
        view_level->insertItem( i18n("Lyrics only") , 100);
 
102
        view_level->setWhatsThis(100, i18n("The info window will<br>\n"
 
103
                                "show only lyrics, if any,<br>\n"
 
104
                                "and the name of the midi file.") );
 
105
        view_level->insertItem( i18n("Normal") , 101);
 
106
        view_level->setWhatsThis(101, i18n("The info window shows<br>\n"
 
107
                                "all displayable midi<br>\n"
 
108
                                "messages.") );
 
109
        view_level->insertItem( i18n("Loading msgs") , 102);
 
110
        view_level->setWhatsThis(102, i18n("Also shows new instruments<br>\n"
 
111
                                "being loaded for playing<br>\n"
 
112
                                "the next song.") );
 
113
        view_level->insertItem( i18n("debug 1") , 103);
 
114
        view_level->setWhatsThis(103, i18n("Also shows instrument<br>\n"
 
115
                                "volume computation.") );
 
116
        view_level->insertItem( i18n("debug 2") , 104);
 
117
        view_level->setWhatsThis(104, i18n("Shows lots of additional<br>\n"
 
118
                                "information (probably not useful).") );
 
119
    connect( view_level, SIGNAL(activated(int)), this, SLOT(doViewInfoLevel(int)) );
 
120
    connect( view_level, SIGNAL(aboutToShow()), this, SLOT(fixInfoLevelItems()) );
 
121
 
 
122
 
 
123
    QPopupMenu *editMenu = new QPopupMenu;
 
124
    menuBar->insertItem( i18n("&Edit"), editMenu, CTRL+Key_E);
 
125
    editMenu->insertItem( i18n("Edit Playlist"), kmidi, SLOT(ejectClicked()), 0, 108);
 
126
        editMenu->setWhatsThis(108, i18n("Transfer the current<br>\n"
 
127
                                "play list to the Playlist Editor<br>\n"
 
128
                                "and start him up.") );
 
129
 
 
130
 
 
131
 
 
132
    stereo_options = new QPopupMenu();
 
133
    CHECK_PTR( stereo_options );
 
134
    stereo_options->setCheckable( TRUE );
 
135
    menuBar->insertItem( i18n("Stereo"), stereo_options );
 
136
    connect( stereo_options, SIGNAL(activated(int)), this, SLOT(doStereoMenuItem(int)) );
 
137
    connect( stereo_options, SIGNAL(aboutToShow()), this, SLOT(fixStereoItems()) );
 
138
        stereo_options->insertItem(  i18n("No stereo patch"), 110 );
 
139
        stereo_options->setWhatsThis(110, i18n("Prevents playing the<br>\n"
 
140
                                "second instrument for those<br>\n"
 
141
                                "patches that have two<br>\n"
 
142
                                "(you probably don't want<br>\n"
 
143
                                "to choose this option).") );
 
144
        stereo_options->insertItem(  i18n("Normal stereo") , 111);
 
145
        stereo_options->setWhatsThis(111, i18n("Plays both instruments<br>\n"
 
146
                                "for those (sf2) patches<br>\n"
 
147
                                "which have two.") );
 
148
        stereo_options->insertItem(  i18n("Extra stereo") , 112);
 
149
        stereo_options->setWhatsThis(112, i18n("For keyboard instruments,<br>\n"
 
150
                                "lower notes come from the left<br>\n"
 
151
                                "For other instruments, position is<br>\n"
 
152
                                "made a function of note<br>\n"
 
153
                                "velocity.") );
 
154
        stereo_options->insertSeparator();
 
155
        stereo_options->insertItem(  i18n("Surround stereo") , 113);
 
156
        stereo_options->setWhatsThis(112, i18n("Extra stereo, echo, and<br>" \
 
157
                                "detuned notes are spread out more<br>" \
 
158
                                "to left and right.") );
 
159
 
 
160
    reverb_options = new QPopupMenu();
 
161
    CHECK_PTR( reverb_options );
 
162
    reverb_options->setCheckable( TRUE );
 
163
    menuBar->insertItem( i18n("Reverb"), reverb_options );
 
164
    connect( reverb_options, SIGNAL(activated(int)), this, SLOT(doReverbMenuItem(int)) );
 
165
    connect( reverb_options, SIGNAL(aboutToShow()), this, SLOT(fixReverbItems()) );
 
166
        reverb_options->insertItem(  i18n("Dry"), 119 );
 
167
        reverb_options->setWhatsThis(119, i18n("With the dry setting,<br>\n"
 
168
                                "after notes are released,<br>\n"
 
169
                                "they are ended by playing<br>\n"
 
170
                                "through the ends of their<br>\n"
 
171
                                "patches (which may cause some<br>\n"
 
172
                                "clicking).  The wet setting makes<br>\n"
 
173
                                "notes continues to the ends of<br>\n"
 
174
                                "their volume envelopes.") );
 
175
    reverb_level = new QPopupMenu();
 
176
    CHECK_PTR( reverb_level );
 
177
    reverb_level->setCheckable( TRUE );
 
178
    reverb_options->insertSeparator();
 
179
    reverb_options->insertItem( i18n("Reverb level"), reverb_level);
 
180
        reverb_level->insertItem( i18n("default") , 160);
 
181
        reverb_level->setWhatsThis(160, i18n("The reverberation level<br>\n"
 
182
                                "is set according to the midi<br>\n"
 
183
                                "channel setting and what the<br>\n"
 
184
                                "instrument patch specifies.") );
 
185
        reverb_level->insertItem( i18n("midi level  32") , 161);
 
186
        reverb_level->setWhatsThis(161, i18n("The reverberation level<br>\n"
 
187
                                "is set to a minimum level of 32." ) );
 
188
        reverb_level->insertItem( i18n("midi level  64") , 162);
 
189
        reverb_level->setWhatsThis(162, i18n("The reverberation level<br>\n"
 
190
                                "is set to a minimum level of 64." ) );
 
191
        reverb_level->insertItem( i18n("midi level  96") , 163);
 
192
        reverb_level->setWhatsThis(163, i18n("The reverberation level<br>\n"
 
193
                                "is set to a minimum level of 96." ) );
 
194
        reverb_level->insertItem( i18n("midi level 127") , 164);
 
195
        reverb_level->setWhatsThis(164, i18n("The reverberation level<br>\n"
 
196
                                "is set to the maximem level of 127." ) );
 
197
    connect( reverb_level, SIGNAL(activated(int)), this, SLOT(doReverbLevel(int)) );
 
198
    connect( reverb_level, SIGNAL(aboutToShow()), this, SLOT(fixReverbLevelItems()) );
 
199
    reverb_options->insertSeparator();
 
200
        reverb_options->insertItem(  i18n("No echo"), 120 );
 
201
        reverb_options->setWhatsThis(120, i18n("Prevents playing extra<br>\n"
 
202
                                "echo notes for reverberation.") );
 
203
        reverb_options->insertItem(  i18n("Normal echo") , 121);
 
204
        reverb_options->setWhatsThis(121, i18n("Extra echo notes are<br>\n"
 
205
                                               "played to get the effect<br>\n"
 
206
                                               "of reverberation.") );
 
207
    echo_level = new QPopupMenu();
 
208
    CHECK_PTR( echo_level );
 
209
    echo_level->setCheckable( TRUE );
 
210
    reverb_options->insertSeparator();
 
211
    reverb_options->insertItem( i18n("Echo level"), echo_level);
 
212
        echo_level->insertItem( i18n("default") , 130);
 
213
        echo_level->setWhatsThis(130, i18n("The level for echo notes<br>\n"
 
214
                                "is set according to the midi<br>\n"
 
215
                                "channel setting and what the<br>\n"
 
216
                                "instrument patch specifies.") );
 
217
        echo_level->insertItem( i18n("midi level  32") , 131);
 
218
        echo_level->setWhatsThis(131, i18n("The echo level<br>\n"
 
219
                                "is set to a minimum level of 32." ) );
 
220
        echo_level->insertItem( i18n("midi level  64") , 132);
 
221
        echo_level->setWhatsThis(132, i18n("The echo level<br>\n"
 
222
                                "is set to a minimum level of 64." ) );
 
223
        echo_level->insertItem( i18n("midi level  96") , 133);
 
224
        echo_level->setWhatsThis(133, i18n("The echo level<br>\n"
 
225
                                "is set to a minimum level of 96." ) );
 
226
        echo_level->insertItem( i18n("midi level 127") , 134);
 
227
        echo_level->setWhatsThis(133, i18n("The echo level<br>\n"
 
228
                                "is set to the maximem level of 127." ) );
 
229
    connect( echo_level, SIGNAL(activated(int)), this, SLOT(doEchoLevel(int)) );
 
230
    connect( echo_level, SIGNAL(aboutToShow()), this, SLOT(fixEchoLevelItems()) );
 
231
 
 
232
 
 
233
    chorus_options = new QPopupMenu();
 
234
    CHECK_PTR( chorus_options );
 
235
    chorus_options->setCheckable( TRUE );
 
236
    menuBar->insertItem( i18n("Chorus"), chorus_options );
 
237
    connect( chorus_options, SIGNAL(activated(int)), this, SLOT(doChorusMenuItem(int)) );
 
238
    connect( chorus_options, SIGNAL(aboutToShow()), this, SLOT(fixChorusItems()) );
 
239
    chorus_level = new QPopupMenu();
 
240
    CHECK_PTR( chorus_level );
 
241
    chorus_level->setCheckable( TRUE );
 
242
    chorus_options->insertItem( i18n("Chorus level"), chorus_level);
 
243
    chorus_level->insertItem( i18n("default") , 170);
 
244
    chorus_level->setWhatsThis(170, i18n("The chorus level<br>\n"
 
245
                                         "is set according to the midi<br>\n"
 
246
                                         "channel setting and what the<br>\n"
 
247
                                         "instrument patch specifies.") );
 
248
    chorus_level->insertItem( i18n("midi level  32") , 171);
 
249
    chorus_level->setWhatsThis(171, i18n("The choruslevel<br>\n"
 
250
                                         "is set to a minimum level of 32." ) );
 
251
    chorus_level->insertItem( i18n("midi level  64") , 172);
 
252
    chorus_level->setWhatsThis(172, i18n("The choruslevel<br>\n"
 
253
                                         "is set to a minimum level of 64." ) );
 
254
    chorus_level->insertItem( i18n("midi level  96") , 173);
 
255
    chorus_level->setWhatsThis(173, i18n("The choruslevel<br>\n"
 
256
                                         "is set to a minimum level of 96." ) );
 
257
    chorus_level->insertItem( i18n("midi level 127") , 174);
 
258
    chorus_level->setWhatsThis(174, i18n("The choruslevel<br>\n"
 
259
                                         "is set to the maximum level of 127." ) );
 
260
    connect( chorus_level, SIGNAL(activated(int)), this, SLOT(doChorusLevel(int)) );
 
261
    connect( chorus_level, SIGNAL(aboutToShow()), this, SLOT(fixChorusLevelItems()) );
 
262
    chorus_options->insertSeparator();
 
263
    chorus_options->insertItem(  i18n("No detune"), 140 );
 
264
    chorus_options->setWhatsThis(140, i18n("Prevents playing extra<br>\n"
 
265
                                           "detuned notes for chorus effect.") );
 
266
    chorus_options->insertItem(  i18n("Normal detune") , 141);
 
267
    chorus_options->setWhatsThis(141, i18n("Extra detuned notes are<br>\n"
 
268
                                           "played to get the effect<br>\n"
 
269
                                           "of chorusing") );
 
270
    detune_level = new QPopupMenu();
 
271
    CHECK_PTR( detune_level );
 
272
    detune_level->setCheckable( TRUE );
 
273
    chorus_options->insertSeparator();
 
274
    chorus_options->insertItem( i18n("Detune level"), detune_level);
 
275
    detune_level->insertItem( i18n("default") , 150);
 
276
    detune_level->setWhatsThis(150, i18n("The level for detuned notes<br>\n"
 
277
                                         "is set according to the midi<br>\n"
 
278
                                         "channel setting and what the<br>\n"
 
279
                                         "instrument patch specifies for"
 
280
                                         "chorus level.") );
 
281
    detune_level->insertItem( i18n("midi level  32") , 151);
 
282
    detune_level->setWhatsThis(151, i18n("The detuning level<br>\n"
 
283
                                         "is set to a minimum level of 32." ) );
 
284
    detune_level->insertItem( i18n("midi level  64") , 152);
 
285
    detune_level->setWhatsThis(152, i18n("The detuning level<br>\n"
 
286
                                         "is set to a minimum level of 64." ) );
 
287
    detune_level->insertItem( i18n("midi level  96") , 153);
 
288
    detune_level->setWhatsThis(153, i18n("The detuning level<br>\n"
 
289
                                         "is set to a minimum level of 96." ) );
 
290
    detune_level->insertItem( i18n("midi level 127") , 154);
 
291
    detune_level->setWhatsThis(154, i18n("The detuning level<br>\n"
 
292
                                         "is set to the maximum level of 127." ) );
 
293
    connect( detune_level, SIGNAL(activated(int)), this, SLOT(doDetuneLevel(int)) );
 
294
    connect( detune_level, SIGNAL(aboutToShow()), this, SLOT(fixDetuneLevelItems()) );
 
295
 
 
296
    volume_options = new QPopupMenu();
 
297
    CHECK_PTR( volume_options );
 
298
    //volume_options->setCheckable( TRUE );
 
299
    menuBar->insertItem( i18n("Volume"), volume_options );
 
300
    //connect( volume_options, SIGNAL(activated(int)), this, SLOT(doVolumeMenuItem(int)) );
 
301
    volume_curve = new QPopupMenu();
 
302
    CHECK_PTR( volume_curve );
 
303
    volume_curve->setCheckable( TRUE );
 
304
    volume_options->insertItem( i18n("Volume Curve"), volume_curve);
 
305
    connect( volume_curve, SIGNAL(activated(int)), this, SLOT(doVolumeCurve(int)) );
 
306
    connect( volume_curve, SIGNAL(aboutToShow()), this, SLOT(fixVolumeCurveItems()) );
 
307
        volume_curve->insertItem( i18n("linear") , 180);
 
308
        volume_curve->setWhatsThis(180, i18n("The midi volume controller<br>" \
 
309
                                "changes the volume linearly." ) );
 
310
        volume_curve->insertItem( i18n("exp 4") , 181);
 
311
        volume_curve->setWhatsThis(181, i18n("The midi volume controller<br>" \
 
312
                                "changes the volume exponentially." ) );
 
313
        volume_curve->insertItem( i18n("exp 6") , 182);
 
314
        volume_curve->setWhatsThis(182, i18n("The midi volume controller<br>" \
 
315
                                "changes the volume exponentially." ) );
 
316
    volume_options->insertSeparator();
 
317
    expression_curve = new QPopupMenu();
 
318
    CHECK_PTR( expression_curve );
 
319
    expression_curve->setCheckable( TRUE );
 
320
    volume_options->insertItem( i18n("Expression Curve"), expression_curve);
 
321
    connect( expression_curve, SIGNAL(activated(int)), this, SLOT(doExpressionCurve(int)) );
 
322
    connect( expression_curve, SIGNAL(aboutToShow()), this, SLOT(fixExpressionCurveItems()) );
 
323
        expression_curve->insertItem( i18n("linear") , 190);
 
324
        expression_curve->setWhatsThis(190, i18n("The midi expression controller<br>" \
 
325
                                "changes the expression linearly." ) );
 
326
        expression_curve->insertItem( i18n("exp 4") , 191);
 
327
        expression_curve->setWhatsThis(191, i18n("The midi expression controller<br>" \
 
328
                                "changes the expression exponentially." ) );
 
329
        expression_curve->insertItem( i18n("exp 6") , 192);
 
330
        expression_curve->setWhatsThis(192, i18n("The midi expression controller<br>" \
 
331
                                "changes the expression exponentially." ) );
 
332
 
 
333
    menuBar->insertSeparator();
 
334
 
 
335
    QString aboutapp = i18n("KDE midi file player\n\n"
 
336
                     "A software synthesizer for playing\n"
 
337
                     "midi songs using Tuukka Toivonen's\n"
 
338
                     "TiMidity");
 
339
 
 
340
    QPopupMenu *about = helpMenu(aboutapp);
 
341
    menuBar->insertItem( i18n("&Help"), about);
 
342
 
 
343
    menuBar->hide();
 
344
    menubarheight = menuBar->heightForWidth(90+220+90);
 
345
    menubarisvisible = false;
 
346
 
 
347
    //kmidi = new KMidi(this, "_kmidi" );
 
348
    setCentralWidget(kmidi);
 
349
 
 
350
    docking = true;
 
351
    dock_widget = new DockWidget(this, "dockw");
 
352
        if(docking){
 
353
        dock_widget->show();
 
354
    }
 
355
 
 
356
}
 
357
 
 
358
KMidiFrame::~KMidiFrame(){
 
359
}
 
360
 
 
361
//void KMidiFrame::resizeEvent(QResizeEvent *e){
 
362
//    int h = (e->size()).height();
 
363
//    int w = (e->size()).width();
 
364
//
 
365
//printf("frame resize %d x %d\n", w, h);
 
366
//    if (e->size() != requestedframesize)
 
367
//      resize(requestedframesize);
 
368
//}
 
369
 
 
370
bool KMidiFrame::queryClose() {
 
371
 
 
372
    kmidi->quitClicked();
 
373
    return true;
 
374
}
 
375
 
 
376
void KMidiFrame::quitClick(){
 
377
 
 
378
    kmidi->quitClicked();
 
379
}
 
380
 
 
381
void KMidiFrame::file_Open() {
 
382
#if 0
 
383
    QStringList files;
 
384
    int newones = 0;
 
385
    char mbuff[5];
 
386
 
 
387
    files = KFileDialog::getOpenFileNames(QString::null, QString::null, this);
 
388
 
 
389
printf("file count %d\n", files.count());
 
390
    for (QStringList::Iterator i=files.begin(); i!=files.end(); ++i) {
 
391
printf("file %s\n", (*i).ascii());
 
392
            QFile f(*i);
 
393
            if (!f.open( IO_ReadOnly )) continue;
 
394
            if (f.readBlock(mbuff, 4) != 4) {
 
395
                f.close();
 
396
                continue;
 
397
            }
 
398
            mbuff[4] = '\0';
 
399
            if (strcmp(mbuff, "MThd")) {
 
400
                f.close();
 
401
                continue;
 
402
            }
 
403
            f.close();
 
404
 
 
405
            kmidi->playlist->insert(0, *i);
 
406
            newones++;
 
407
    }
 
408
 
 
409
    if (newones) {
 
410
        kmidi->redoplaybox();
 
411
        kmidi->setSong(0);
 
412
    }
 
413
#endif
 
414
 
 
415
#if 0
 
416
    //QString filename=KFileDialog::getOpenFileURL(QString::null, QString::null,this);
 
417
    //QString filename = KFileDialog::getOpenFileName(QString::null, QString::null, this);
 
418
    QString filename = KMidiFileDlg::getOpenFileName(QString::null, QString::null, this);
 
419
    if (!filename.isNull())
 
420
    {
 
421
        kmidi->playlist->insert(0, filename);
 
422
        kmidi->restartPlaybox();
 
423
        //kmidi->redoplaybox();
 
424
        //kmidi->resetSong();
 
425
    }
 
426
#endif
 
427
 
 
428
    QString dpath = kmidi->current_dir.absPath();
 
429
    KMidiFileDlg::getOpenDialog(dpath, QString::null, this);
 
430
}
 
431
void KMidiFrame::doViewMenuItem(int id) {
 
432
    if (id == m_off_id) kmidi->logoClicked();
 
433
    else if (id == i_on_id || id == i_off_id) kmidi->infoslot();
 
434
}
 
435
 
 
436
void KMidiFrame::fixViewItems() {
 
437
    view_options->setItemChecked( m_on_id, true);
 
438
    view_options->setItemChecked( m_off_id, false);
 
439
    view_options->setItemChecked( i_on_id, kmidi->logwindow->isVisible());
 
440
    view_options->setItemChecked( i_off_id, !kmidi->logwindow->isVisible());
 
441
}
 
442
void KMidiFrame::doViewInfoLevel(int id) {
 
443
    if (id >= 100 && id <= 104 && (id-100 != kmidi->verbosity_state) ) {
 
444
        if (id == 100) kmidi->rcb4->setChecked(false);
 
445
        else if (id == 101) kmidi->rcb4->setNoChange();
 
446
        else if (id >= 102) kmidi->rcb4->setChecked(true);
 
447
        kmidi->verbosity_state = id-100;
 
448
        kmidi->updateRChecks(3);
 
449
    }
 
450
}
 
451
void KMidiFrame::fixInfoLevelItems() {
 
452
    view_level->setItemChecked( 100, kmidi->verbosity_state == 0);
 
453
    view_level->setItemChecked( 101, kmidi->verbosity_state == 1);
 
454
    view_level->setItemChecked( 102, kmidi->verbosity_state == 2);
 
455
    view_level->setItemChecked( 103, kmidi->verbosity_state == 3);
 
456
    view_level->setItemChecked( 104, kmidi->verbosity_state == 4);
 
457
}
 
458
void KMidiFrame::doStereoMenuItem(int id) {
 
459
    if (id >= 110 && id <= 112 && (id-110 != kmidi->stereo_state) ) {
 
460
        if (id == 110) kmidi->rcb1->setChecked(false);
 
461
        else if (id == 111) kmidi->rcb1->setNoChange();
 
462
        else if (id == 112) kmidi->rcb1->setChecked(true);
 
463
        kmidi->updateRChecks(0);
 
464
    }
 
465
    else if (id == 113) {
 
466
        if (( kmidi->evs_state  & 0x0f ) == 1) kmidi->setSurround(0);
 
467
        else kmidi->setSurround(1);
 
468
    }
 
469
}
 
470
void KMidiFrame::fixStereoItems() {
 
471
    stereo_options->setItemChecked( 110, kmidi->stereo_state == 0);
 
472
    stereo_options->setItemChecked( 111, kmidi->stereo_state == 1);
 
473
    stereo_options->setItemChecked( 112, kmidi->stereo_state == 2);
 
474
    stereo_options->setItemChecked( 113, ( kmidi->evs_state  & 0x0f ) == 1);
 
475
}
 
476
void KMidiFrame::doReverbMenuItem(int id) {
 
477
    if (id == 119) kmidi->setDry(!kmidi->dry_state);
 
478
    else if (id >= 120 && id <= 121 && (id-120 != kmidi->echo_state) ) {
 
479
        if (id == 120) kmidi->rcb2->setChecked(false);
 
480
        else if (id == 121) kmidi->rcb2->setNoChange();
 
481
        kmidi->updateRChecks(1);
 
482
    }
 
483
}
 
484
void KMidiFrame::fixReverbItems() {
 
485
    reverb_options->setItemChecked( 119, kmidi->dry_state);
 
486
    reverb_options->setItemChecked( 120, kmidi->echo_state == 0);
 
487
    reverb_options->setItemChecked( 121, kmidi->echo_state == 1);
 
488
}
 
489
void KMidiFrame::doReverbLevel(int id) {
 
490
    kmidi->setReverb(id - 160);
 
491
}
 
492
void KMidiFrame::doEchoLevel(int id) {
 
493
    if (id == 130 && kmidi->echo_state >= 2) {
 
494
        //kmidi->rcb2->setChecked(false);
 
495
        kmidi->rcb2->setNoChange();
 
496
        kmidi->updateRChecks(1);
 
497
    }
 
498
    else if (kmidi->echo_state != id-129) {
 
499
        kmidi->rcb2->setChecked(true);
 
500
        kmidi->echo_state = id-129;
 
501
        kmidi->updateRChecks(1);
 
502
    }
 
503
}
 
504
void KMidiFrame::fixEchoLevelItems() {
 
505
    echo_level->setItemChecked( 130, kmidi->echo_state < 2);
 
506
    echo_level->setItemChecked( 131, kmidi->echo_state == 2);
 
507
    echo_level->setItemChecked( 132, kmidi->echo_state == 3);
 
508
    echo_level->setItemChecked( 133, kmidi->echo_state == 4);
 
509
    echo_level->setItemChecked( 134, kmidi->echo_state == 5);
 
510
}
 
511
void KMidiFrame::fixReverbLevelItems() {
 
512
    reverb_level->setItemChecked( 160, kmidi->reverb_state == 0);
 
513
    reverb_level->setItemChecked( 161, kmidi->reverb_state == 1);
 
514
    reverb_level->setItemChecked( 162, kmidi->reverb_state == 2);
 
515
    reverb_level->setItemChecked( 163, kmidi->reverb_state == 3);
 
516
    reverb_level->setItemChecked( 164, kmidi->reverb_state == 4);
 
517
}
 
518
void KMidiFrame::doChorusMenuItem(int id) {
 
519
    if (id >= 140 && id <= 141 && (id-140 != kmidi->detune_state) ) {
 
520
        if (id == 140) kmidi->rcb3->setChecked(false);
 
521
        else if (id == 141) kmidi->rcb3->setNoChange();
 
522
        kmidi->updateRChecks(2);
 
523
    }
 
524
}
 
525
void KMidiFrame::fixChorusItems() {
 
526
    chorus_options->setItemChecked( 140, kmidi->detune_state == 0);
 
527
    chorus_options->setItemChecked( 141, kmidi->detune_state == 1);
 
528
}
 
529
void KMidiFrame::doChorusLevel(int id) {
 
530
    kmidi->setChorus(id - 170);
 
531
}
 
532
void KMidiFrame::doDetuneLevel(int id) {
 
533
    if (id == 150 && kmidi->detune_state >= 2) {
 
534
        kmidi->rcb3->setNoChange();
 
535
        kmidi->updateRChecks(2);
 
536
    }
 
537
    else if (kmidi->detune_state != id-149) {
 
538
        kmidi->rcb3->setChecked(true);
 
539
        kmidi->detune_state = id-149;
 
540
        kmidi->updateRChecks(2);
 
541
    }
 
542
}
 
543
void KMidiFrame::fixChorusLevelItems() {
 
544
    chorus_level->setItemChecked( 170, kmidi->chorus_state == 0);
 
545
    chorus_level->setItemChecked( 171, kmidi->chorus_state == 1);
 
546
    chorus_level->setItemChecked( 172, kmidi->chorus_state == 2);
 
547
    chorus_level->setItemChecked( 173, kmidi->chorus_state == 3);
 
548
    chorus_level->setItemChecked( 174, kmidi->chorus_state == 4);
 
549
}
 
550
void KMidiFrame::fixDetuneLevelItems() {
 
551
    detune_level->setItemChecked( 150, kmidi->detune_state < 2);
 
552
    detune_level->setItemChecked( 151, kmidi->detune_state == 2);
 
553
    detune_level->setItemChecked( 152, kmidi->detune_state == 3);
 
554
    detune_level->setItemChecked( 153, kmidi->detune_state == 4);
 
555
    detune_level->setItemChecked( 154, kmidi->detune_state == 5);
 
556
}
 
557
void KMidiFrame::doVolumeCurve(int id) {
 
558
    kmidi->setVolumeCurve(id - 180);
 
559
}
 
560
void KMidiFrame::fixVolumeCurveItems() {
 
561
    int v_state = (kmidi->evs_state >> 4) & 0x0f;
 
562
    volume_curve->setItemChecked( 180, v_state == 0);
 
563
    volume_curve->setItemChecked( 181, v_state == 1);
 
564
    volume_curve->setItemChecked( 182, v_state == 2);
 
565
}
 
566
void KMidiFrame::doExpressionCurve(int id) {
 
567
    kmidi->setExpressionCurve(id - 190);
 
568
}
 
569
void KMidiFrame::fixExpressionCurveItems() {
 
570
    int e_state = (kmidi->evs_state >> 8) & 0x0f;
 
571
    expression_curve->setItemChecked( 190, e_state == 0);
 
572
    expression_curve->setItemChecked( 191, e_state == 1);
 
573
    expression_curve->setItemChecked( 192, e_state == 2);
 
574
}
 
575
 
 
576
#include "kmidiframe.moc"
 
577