← Back to branch summary

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

« back to all changes in this revision

Viewing changes to kmidi/TIMIDITY/motif_i.c

  • 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/TIMIDITY/motif_i.c
 
1
/* 
 
2
   
 
3
   TiMidity -- Experimental MIDI to WAVE converter
 
4
   Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
 
5
   
 
6
   This program is free software; you can redistribute it and/or modify
 
7
   it under the terms of the GNU General Public License as published by
 
8
   the Free Software Foundation; either version 2 of the License, or
 
9
   (at your option) any later version.
 
10
   
 
11
   This program is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
   GNU General Public License for more details.
 
15
   
 
16
   You should have received a copy of the GNU General Public License
 
17
   along with this program; if not, write to the Free Software
 
18
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
   
 
20
   motif_interface.c: written by Vincent Pagel (pagel@loria.fr) 10/4/95
 
21
   
 
22
   Policy : I choose to make a separate process for a TIMIDITY motif 
 
23
   interface for TIMIDITY (if the interface was in the same process
 
24
   X redrawings would interfere with the audio computation. Besides 
 
25
   XtAppAddWorkProc mechanism is not easily controlable)
 
26
   
 
27
   The solution : I create a pipe between Timidity and the forked interface
 
28
   and use XtAppAddInput to watch the data arriving on the pipe.
 
29
 
 
30
   10/4/95 
 
31
     - Initial working version with prev, next, and quit button and a
 
32
       text display
 
33
 
 
34
   17/5/95 
 
35
     - Add timidity icon with filename displaying to play midi while 
 
36
       I work without having that big blue window in the corner of 
 
37
       my screen :)
 
38
     - Solve the problem of concurent scale value modification
 
39
 
 
40
   21/5/95
 
41
     - Add menus, file selection box
 
42
   
 
43
   14/6/95
 
44
     - Make the visible part of file list follow the selection
 
45
 
 
46
   */
 
47
 
 
48
#ifdef IA_MOTIF
 
49
 
 
50
#include <stdio.h>
 
51
#include <stdlib.h>
 
52
#include <unistd.h>
 
53
#include <stdarg.h>
 
54
 
 
55
/* extern "C" {
 
56
 
 
57
#ifndef NeedFunctionPrototypes
 
58
#define NeedFunctionPrototypes
 
59
#endif
 
60
*/
 
61
 
 
62
#include <X11/IntrinsicP.h>
 
63
#include <Xm/Xm.h>
 
64
#include <Xm/Form.h>
 
65
#include <Xm/Text.h>
 
66
#include <Xm/PushB.h>
 
67
#include <Xm/Label.h>
 
68
#include <Xm/Scale.h>
 
69
#include <Xm/List.h>
 
70
#include <Xm/Frame.h>
 
71
#include <Xm/RowColumn.h>
 
72
#include <Xm/CascadeB.h>
 
73
#include <Xm/FileSB.h>
 
74
#include <Xm/FileSB.h>
 
75
#include <Xm/ToggleB.h>
 
76
 
 
77
/* } */
 
78
 
 
79
#include "config.h"
 
80
#include "common.h"
 
81
#include "instrum.h"
 
82
#include "playmidi.h"
 
83
#include "output.h"
 
84
#include "controls.h"
 
85
#include "motif.h"
 
86
 
 
87
void handle_input(XtPointer client_data, int *source, XtInputId *id);
 
88
 
 
89
XtAppContext context;
 
90
XmStringCharSet char_set=XmSTRING_DEFAULT_CHARSET;
 
91
 
 
92
Widget toplevel;
 
93
 
 
94
Widget text;
 
95
Widget text;
 
96
Widget parenttext;
 
97
static XmTextPosition wpr_position=0;
 
98
 
 
99
Widget mainForm; 
 
100
 
 
101
Widget menu_bar, open_option, quit_option, auto_next_option;
 
102
Widget open_dialog , add_all_button;
 
103
 
 
104
Widget btnForm, backBtn,fwdBtn, restartBtn, pauseBtn, quitBtn,
 
105
       nextBtn, prevBtn;
 
106
 
 
107
Pixmap backPixmap, fwdPixmap, pausePixmap , restartPixmap, 
 
108
       playPixmap, prevPixmap, nextPixmap, quitPixmap,
 
109
       timidityPixmap;
 
110
 
 
111
Widget countFrame, countForm, counterlbl, totlbl , count_headlbl;
 
112
int last_sec=0;
 
113
int max_sec=0;
 
114
 
 
115
Widget file_namelbl, file_headlbl;
 
116
 
 
117
Widget volume_scale , locator_scale ;
 
118
Boolean locator_scale_button= ButtonRelease;
 
119
 
 
120
Widget file_list;
 
121
int file_number_to_play; /* Number of the file we're playing in the list */
 
122
 
 
123
/*
 
124
 * CREATE PIXMAPS FOR THE BUTONS
 
125
 */
 
126
void CreatePixmaps(Widget parent)
 
127
{
 
128
  /*
 
129
   * 
 
130
   * BITMAPS 
 
131
   */
 
132
    #include "BITMAPS/back.xbm"
 
133
    #include "BITMAPS/next.xbm"
 
134
    #include "BITMAPS/prev.xbm"
 
135
    #include "BITMAPS/restart.xbm"
 
136
    #include "BITMAPS/fwd.xbm"
 
137
    #include "BITMAPS/pause.xbm"
 
138
    #include "BITMAPS/quit.xbm"
 
139
    #include "BITMAPS/timidity.xbm"
 
140
 
 
141
    Display *disp;
 
142
    Drawable d;
 
143
    Pixel fg,bg;
 
144
    int ac;
 
145
    Arg al[20];
 
146
    unsigned int depth=DefaultDepthOfScreen(XtScreen(toplevel));
 
147
 
 
148
    ac = 0;
 
149
    XtSetArg(al[ac], XmNbackground, &bg); ac++;
 
150
    XtSetArg(al[ac], XmNforeground, &fg); ac++;
 
151
    XtGetValues(parent, al, ac);
 
152
 
 
153
    disp=XtDisplay(toplevel);
 
154
    d=RootWindowOfScreen(XtScreen(toplevel));
 
155
    
 
156
    backPixmap = XCreatePixmapFromBitmapData(disp, d,
 
157
                                             back_bits, back_width, back_height,
 
158
                                             fg, bg,depth);
 
159
    fwdPixmap = XCreatePixmapFromBitmapData( disp, d,
 
160
                                             fwd_bits, fwd_width, fwd_height,
 
161
                                             fg, bg,depth);
 
162
    pausePixmap = XCreatePixmapFromBitmapData(disp, d,
 
163
                                        pause_bits, pause_width, pause_height,
 
164
                                        fg, bg,depth);
 
165
    
 
166
    restartPixmap = XCreatePixmapFromBitmapData(disp, d,
 
167
                                          restart_bits, restart_width, restart_height,
 
168
                                          fg, bg,depth);
 
169
    
 
170
    nextPixmap  = XCreatePixmapFromBitmapData(disp, d,
 
171
                                        next_bits, next_width, next_height,
 
172
                                        fg, bg,depth);
 
173
    
 
174
    prevPixmap  = XCreatePixmapFromBitmapData(disp, d,
 
175
                                        prev_bits, prev_width, prev_height,
 
176
                                        fg, bg,depth);
 
177
    
 
178
    quitPixmap  = XCreatePixmapFromBitmapData(disp, d,
 
179
                                        quit_bits, quit_width, quit_height,
 
180
                                        fg, bg,depth);
 
181
 
 
182
    timidityPixmap  = XCreatePixmapFromBitmapData(disp, d,
 
183
                                                  timidity_bits, timidity_width, timidity_height,
 
184
                                                  WhitePixelOfScreen(XtScreen(toplevel)),
 
185
                                                  BlackPixelOfScreen(XtScreen(toplevel)),depth);
 
186
}
 
187
 
 
188
 
 
189
/************************************
 
190
 *                                  *
 
191
 * ALL THE INTERFACE'S CALLBACKS    *
 
192
 *                                  *
 
193
 ************************************/
 
194
 
 
195
/*
 
196
 * Generic buttons callbacks ( Transport Buttons )
 
197
 */
 
198
void  GenericCB(Widget widget, int data, XtPointer call_data)
 
199
{
 
200
    motif_pipe_int_write( data );
 
201
}
 
202
 
 
203
/*
 
204
 *  Generic scales callbacks : VOLUME and LOCATOR
 
205
 */
 
206
void Generic_scaleCB(Widget widget, int data, XtPointer call_data)
 
207
{ 
 
208
    XmScaleCallbackStruct *cbs = (XmScaleCallbackStruct *) call_data;
 
209
    
 
210
    motif_pipe_int_write(  data );
 
211
    motif_pipe_int_write(cbs->value);
 
212
}
 
213
 
 
214
/* 
 
215
 * Detect when a mouse button is pushed or released in a scale area to
 
216
 * avoid concurent scale value modification while holding it with the mouse
 
217
 */
 
218
void Locator_btn(Widget w,XtPointer client_data,XEvent *event,Boolean *cont)
 
219
{ 
 
220
    /* Type = ButtonPress or ButtonRelease */
 
221
    locator_scale_button= event->xbutton.type;
 
222
}
 
223
 
 
224
/*
 
225
 * File List selection CALLBACK
 
226
 */
 
227
void File_ListCB(Widget widget, int data, XtPointer call_data)
 
228
{
 
229
    XmListCallbackStruct *cbs= (XmListCallbackStruct *) call_data;
 
230
    char *text;
 
231
    int nbvisible, first_visible ;
 
232
    Arg al[10];
 
233
    int ac;
 
234
    
 
235
    /* First, check that the selected file is really visible in the list */
 
236
    ac=0;
 
237
    XtSetArg(al[ac],XmNtopItemPosition,&first_visible); ac++;
 
238
    XtSetArg(al[ac],XmNvisibleItemCount,&nbvisible); ac++;
 
239
    XtGetValues(widget, al, ac);
 
240
     
 
241
    if ( ( first_visible > cbs->item_position) ||
 
242
         ((first_visible+nbvisible) <= cbs->item_position))
 
243
        XmListSetPos(widget, cbs->item_position);
 
244
 
 
245
    /* Tell the application to play the requested file */
 
246
    XmStringGetLtoR(cbs->item,char_set,&text);
 
247
    motif_pipe_int_write(MOTIF_PLAY_FILE);
 
248
    motif_pipe_string_write(text);
 
249
    file_number_to_play=cbs->item_position;
 
250
    XtFree(text);
 
251
}
 
252
 
 
253
/*
 
254
 * Generic menu callback
 
255
 */
 
256
void menuCB(Widget w,int client_data,XmAnyCallbackStruct *call_data)
 
257
{
 
258
    switch (client_data)
 
259
        {
 
260
        case MENU_OPEN: 
 
261
        {
 
262
            XtManageChild(open_dialog);
 
263
        }
 
264
        break;
 
265
        
 
266
        case MENU_QUIT : {
 
267
            motif_pipe_int_write(MOTIF_QUIT);
 
268
        }
 
269
            break;
 
270
        case MENU_TOGGLE : {
 
271
            /* Toggle modified : for the moment , nothing to do ! */
 
272
            /* if (XmToggleButtonGetState(w)) TRUE else FALSE */
 
273
            }
 
274
            break;
 
275
        }
 
276
}
 
277
 
 
278
/* 
 
279
 * File selection box callback 
 
280
 */
 
281
void openCB(Widget w,int client_data,XmFileSelectionBoxCallbackStruct *call_data)
 
282
{ 
 
283
    if (client_data==DIALOG_CANCEL)
 
284
        { /* do nothing if cancel is selected. */
 
285
            XtUnmanageChild(open_dialog);
 
286
            return;
 
287
        }
 
288
    else if (client_data==DIALOG_ALL)
 
289
        { /* Add all the listed files  */
 
290
            Arg al[10];
 
291
            int ac;
 
292
            Widget the_list;
 
293
            int nbfile;
 
294
            XmStringTable files;
 
295
            int i;
 
296
                    
 
297
            the_list=XmFileSelectionBoxGetChild(open_dialog,XmDIALOG_LIST);
 
298
            if (!XmIsList(the_list))
 
299
                {
 
300
                    printf("PANIC: List are not what they used to be\n");
 
301
                    exit;
 
302
                }
 
303
            
 
304
            ac=0;
 
305
            XtSetArg(al[ac], XmNitemCount, &nbfile); ac++;
 
306
            XtSetArg(al[ac], XmNitems, &files); ac++;
 
307
            XtGetValues(the_list, al, ac);
 
308
            
 
309
            for (i=0;i<nbfile;i++)
 
310
                XmListAddItemUnselected(file_list,files[i],0);
 
311
        }
 
312
    else
 
313
        {   /* get filename from file selection box and add it to the list*/
 
314
            XmListAddItemUnselected(file_list,call_data->value,0);
 
315
            XtUnmanageChild(open_dialog);
 
316
        }
 
317
}
 
318
 
 
319
 
 
320
/********************************************************
 
321
 *                                                      *
 
322
 * Receive DATA sent by the application on the pipe     *
 
323
 *                                                      *
 
324
 ********************************************************/
 
325
void handle_input(XtPointer client_data, int *source, XtInputId *id)
 
326
{
 
327
    int message;
 
328
     
 
329
    motif_pipe_int_read(&message);
 
330
 
 
331
    switch (message)
 
332
        {
 
333
        case REFRESH_MESSAGE : {
 
334
            printf("REFRESH MESSAGE IS OBSOLETE !!!\n");
 
335
        }
 
336
            break;
 
337
            
 
338
        case TOTALTIME_MESSAGE : { 
 
339
            int cseconds;
 
340
            int minutes,seconds;
 
341
            char local_string[20];
 
342
            Arg al[10];
 
343
            int ac;
 
344
 
 
345
            motif_pipe_int_read(&cseconds);
 
346
            
 
347
            seconds=cseconds/100;
 
348
            minutes=seconds/60;
 
349
            seconds-=minutes*60;
 
350
            sprintf(local_string,"/ %i:%02i",minutes,seconds);
 
351
            ac=0;
 
352
            XtSetArg(al[ac], XmNlabelString,
 
353
                     XmStringCreate(local_string, char_set)); ac++;
 
354
            XtSetValues(totlbl, al, ac);
 
355
            
 
356
            /* Readjust the time scale */
 
357
            XmScaleSetValue(locator_scale,0);
 
358
            ac=0;
 
359
            XtSetArg(al[ac], XmNmaximum, cseconds); ac++;
 
360
            XtSetValues(locator_scale, al, ac);
 
361
            max_sec=cseconds;
 
362
        }
 
363
            break;
 
364
            
 
365
        case MASTERVOL_MESSAGE: { 
 
366
            int volume;
 
367
            
 
368
            motif_pipe_int_read(&volume);
 
369
            XmScaleSetValue(volume_scale,volume);
 
370
        }
 
371
            break;
 
372
            
 
373
        case FILENAME_MESSAGE : {
 
374
            char filename[255], separator[255];
 
375
            Arg al[10];
 
376
            char *pc;
 
377
            int ac, i;
 
378
            short nbcol;
 
379
            
 
380
            motif_pipe_string_read(filename);
 
381
 
 
382
            /* Extract basename of the file */
 
383
            pc=strrchr(filename,'/');
 
384
            if (pc==NULL)
 
385
                pc=filename;
 
386
            else 
 
387
                pc++;
 
388
            
 
389
            ac=0;
 
390
            XtSetArg(al[ac], XmNlabelString,
 
391
                     XmStringCreate(pc, char_set)); ac++;
 
392
            XtSetValues(file_namelbl, al, ac);
 
393
            
 
394
            /* Change the icon  */
 
395
            ac=0;
 
396
            XtSetArg(al[ac], XmNiconName,pc); ac++;
 
397
            XtSetValues(toplevel,al,ac);
 
398
 
 
399
            /* Put a separator in the text Window */
 
400
            ac=0;
 
401
            XtSetArg(al[ac], XmNcolumns,&nbcol); ac++;
 
402
            XtGetValues(text,al,ac);
 
403
            
 
404
            for (i=0;i<nbcol;i++)
 
405
                separator[i]='*';
 
406
            separator[i]='\0';
 
407
 
 
408
            XmTextInsert(text,wpr_position, separator);
 
409
            wpr_position+= strlen(separator);
 
410
            XmTextInsert(text,wpr_position++,"\n");
 
411
            XtVaSetValues(text,XmNcursorPosition, wpr_position,NULL);
 
412
            XmTextShowPosition(text,wpr_position);
 
413
        }
 
414
            break;
 
415
        
 
416
        case FILE_LIST_MESSAGE : {
 
417
            char filename[255];
 
418
            int i, number_of_files;
 
419
            XmString s;
 
420
            
 
421
            /* reset the playing list : play from the start */
 
422
            file_number_to_play=0;
 
423
            
 
424
            motif_pipe_int_read(&number_of_files);
 
425
            
 
426
            for (i=0;i<number_of_files;i++)
 
427
                {
 
428
                    motif_pipe_string_read(filename);
 
429
                    s=XmStringCreate(filename,char_set);
 
430
                    XmListAddItemUnselected(file_list,s,0);
 
431
                    XmStringFree(s);
 
432
                }
 
433
        }
 
434
            break;
 
435
            
 
436
        case NEXT_FILE_MESSAGE :
 
437
        case PREV_FILE_MESSAGE : 
 
438
        case TUNE_END_MESSAGE :{
 
439
            Arg al[10];
 
440
            int ac;
 
441
            int nbfile;
 
442
            
 
443
            /* When a file ends, launch next if auto_next toggle */
 
444
            if ((message==TUNE_END_MESSAGE) &&
 
445
                !XmToggleButtonGetState(auto_next_option))
 
446
                return;
 
447
            
 
448
            /* Total number of file to play in the list */
 
449
            ac=0;
 
450
            XtSetArg(al[ac], XmNitemCount, &nbfile); ac++;
 
451
            XtGetValues(file_list, al, ac);
 
452
            XmListDeselectAllItems(file_list); 
 
453
            
 
454
            if (message==PREV_FILE_MESSAGE)
 
455
                file_number_to_play--;
 
456
            else 
 
457
                file_number_to_play++;
 
458
 
 
459
            /* Do nothing if requested file is before first one */
 
460
            if (file_number_to_play<0)
 
461
                {
 
462
                    file_number_to_play=1;
 
463
                    return;
 
464
                }
 
465
 
 
466
            /* Stop after playing the last file */
 
467
            if (file_number_to_play>nbfile)
 
468
                { 
 
469
                    file_number_to_play=nbfile;
 
470
                    return;
 
471
                }
 
472
            
 
473
            XmListSelectPos(file_list,file_number_to_play,TRUE);
 
474
        }
 
475
            break;
 
476
 
 
477
        case CURTIME_MESSAGE : { 
 
478
            int cseconds;
 
479
            int  sec,seconds, minutes;
 
480
            int nbvoice;
 
481
            char local_string[20];
 
482
            Arg al[10];
 
483
            int ac;
 
484
 
 
485
            motif_pipe_int_read(&cseconds);
 
486
            motif_pipe_int_read(&nbvoice);
 
487
            
 
488
            sec=seconds=cseconds/100;
 
489
            
 
490
                                /* To avoid blinking */
 
491
            if (sec!=last_sec)
 
492
                {
 
493
                    minutes=seconds/60;
 
494
                    seconds-=minutes*60;
 
495
                    
 
496
                    sprintf(local_string,"%2d:%02d",
 
497
                            minutes, seconds);
 
498
            
 
499
                    ac=0;
 
500
                    XtSetArg(al[ac], XmNlabelString,
 
501
                             XmStringCreate(local_string, char_set)); ac++;
 
502
                    XtSetValues(counterlbl, al, ac);
 
503
                }
 
504
 
 
505
            last_sec=sec;
 
506
            
 
507
            /* Readjust the time scale if not dragging the scale */
 
508
            if ( (locator_scale_button==ButtonRelease) &&
 
509
                 (cseconds<=max_sec))
 
510
                XmScaleSetValue(locator_scale, cseconds);
 
511
        }
 
512
            break;
 
513
            
 
514
        case NOTE_MESSAGE : {
 
515
            int channel;
 
516
            int note;
 
517
            
 
518
            motif_pipe_int_read(&channel);
 
519
            motif_pipe_int_read(&note);
 
520
            printf("NOTE chn%i %i\n",channel,note);
 
521
        }
 
522
            break;
 
523
            
 
524
        case    PROGRAM_MESSAGE :{
 
525
            int channel;
 
526
            int pgm;
 
527
            
 
528
            motif_pipe_int_read(&channel);
 
529
            motif_pipe_int_read(&pgm);
 
530
            printf("NOTE chn%i %i\n",channel,pgm);
 
531
        }
 
532
            break;
 
533
            
 
534
        case VOLUME_MESSAGE : { 
 
535
            int channel;
 
536
            int volume;
 
537
            
 
538
            motif_pipe_int_read(&channel);
 
539
            motif_pipe_int_read(&volume);
 
540
            printf("VOLUME= chn%i %i \n",channel, volume);
 
541
        }
 
542
            break;
 
543
            
 
544
            
 
545
        case EXPRESSION_MESSAGE : { 
 
546
            int channel;
 
547
            int express;
 
548
            
 
549
            motif_pipe_int_read(&channel);
 
550
            motif_pipe_int_read(&express);
 
551
            printf("EXPRESSION= chn%i %i \n",channel, express);
 
552
        }
 
553
            break;
 
554
            
 
555
        case PANNING_MESSAGE : { 
 
556
            int channel;
 
557
            int pan;
 
558
            
 
559
            motif_pipe_int_read(&channel);
 
560
            motif_pipe_int_read(&pan);
 
561
            printf("PANNING= chn%i %i \n",channel, pan);
 
562
        }
 
563
            break;
 
564
            
 
565
        case  SUSTAIN_MESSAGE : { 
 
566
            int channel;
 
567
            int sust;
 
568
            
 
569
            motif_pipe_int_read(&channel);
 
570
            motif_pipe_int_read(&sust);
 
571
            printf("SUSTAIN= chn%i %i \n",channel, sust);
 
572
        }
 
573
            break;
 
574
            
 
575
        case  PITCH_MESSAGE : { 
 
576
            int channel;
 
577
            int bend;
 
578
            
 
579
            motif_pipe_int_read(&channel);
 
580
            motif_pipe_int_read(&bend);
 
581
            printf("PITCH BEND= chn%i %i \n",channel, bend);
 
582
        }
 
583
            break;
 
584
            
 
585
        case RESET_MESSAGE : {
 
586
            printf("RESET_MESSAGE\n");
 
587
        }
 
588
            break;   
 
589
            
 
590
        case CLOSE_MESSAGE : {
 
591
            /* printf("CLOSE_MESSAGE\n"); */
 
592
            exit(0);
 
593
        }
 
594
            break;
 
595
            
 
596
        case CMSG_MESSAGE : { 
 
597
            int type;
 
598
            char message[1000];
 
599
            
 
600
            motif_pipe_int_read(&type);
 
601
            motif_pipe_string_read(message);
 
602
 
 
603
            if (*message == '~') {
 
604
                XmTextInsert(text,wpr_position, message+1);
 
605
                wpr_position+= strlen(message) - 1;
 
606
            }
 
607
            else {
 
608
                XmTextInsert(text,wpr_position, message);
 
609
                wpr_position+= strlen(message);
 
610
                XmTextInsert(text,wpr_position++,"\n");
 
611
            }
 
612
            XtVaSetValues(text,XmNcursorPosition, wpr_position,NULL);
 
613
            XmTextShowPosition(text,wpr_position);
 
614
        }
 
615
            break;
 
616
        default:    
 
617
            fprintf(stderr,"UNKNOWN MOTIF MESSAGE %i\n",message);
 
618
        }
 
619
    
 
620
}
 
621
 
 
622
/* ***************************************
 
623
 *                                       *
 
624
 * Convenience function to create menus  *
 
625
 *                                       *
 
626
 *****************************************/
 
627
 
 
628
/* adds an accelerator to a menu option. */
 
629
void add_accelerator(Widget w, const char *acc_text, const char *key)
 
630
{
 
631
    int ac;
 
632
    Arg al[10];
 
633
    
 
634
    ac=0;
 
635
    XtSetArg(al[ac],XmNacceleratorText,
 
636
             XmStringCreate((char *)acc_text,char_set)); ac++;
 
637
    XtSetArg(al[ac],XmNaccelerator,key); ac++;
 
638
    XtSetValues(w,al,ac);
 
639
}
 
640
 
 
641
/* Adds a toggle option to an existing menu. */
 
642
Widget make_menu_toggle(const char *item_name, int client_data, Widget menu)
 
643
{
 
644
    int ac;
 
645
    Arg al[10];
 
646
    Widget item;
 
647
 
 
648
    ac = 0;
 
649
    XtSetArg(al[ac],XmNlabelString, XmStringCreateLtoR((char *)item_name,
 
650
                                                       char_set)); ac++;
 
651
    item=XmCreateToggleButton(menu,(char *)item_name,al,ac);
 
652
    XtManageChild(item);
 
653
    XtAddCallback(item, XmNvalueChangedCallback, 
 
654
                  (XtCallbackProc) menuCB,(XtPointer) client_data);
 
655
    XtSetSensitive(item, True);
 
656
    return(item);
 
657
}
 
658
 
 
659
/* Adds an option to an existing menu. */
 
660
Widget make_menu_option(const char *option_name, KeySym mnemonic,
 
661
                        int client_data, Widget menu)
 
662
{
 
663
    int ac;
 
664
    Arg al[10];
 
665
    Widget b;
 
666
    
 
667
    ac = 0;
 
668
    XtSetArg(al[ac], XmNlabelString,
 
669
             XmStringCreateLtoR((char *)option_name, char_set)); ac++;
 
670
    XtSetArg (al[ac], XmNmnemonic, mnemonic); ac++;
 
671
    b=XtCreateManagedWidget(option_name,xmPushButtonWidgetClass,
 
672
                            menu,al,ac);
 
673
    XtAddCallback (b, XmNactivateCallback,
 
674
                   (XtCallbackProc) menuCB, (XtPointer) client_data);
 
675
    return(b);
 
676
}
 
677
 
 
678
/* Creates a new menu on the menu bar. */
 
679
Widget make_menu(const char *menu_name,KeySym  mnemonic, Widget menu_bar)
 
680
{
 
681
    int ac;
 
682
    Arg al[10];
 
683
    Widget menu, cascade;
 
684
 
 
685
    ac = 0;
 
686
    menu = XmCreatePulldownMenu (menu_bar, (char *)menu_name, al, ac);
 
687
 
 
688
    ac = 0;
 
689
    XtSetArg (al[ac], XmNsubMenuId, menu); ac++;
 
690
    XtSetArg (al[ac], XmNmnemonic, mnemonic); ac++;
 
691
    XtSetArg(al[ac], XmNlabelString,
 
692
        XmStringCreateLtoR((char *)menu_name, char_set)); ac++;
 
693
    cascade = XmCreateCascadeButton (menu_bar, (char *)menu_name, al, ac);
 
694
    XtManageChild (cascade); 
 
695
 
 
696
    return(menu);
 
697
}
 
698
 
 
699
/* *******************************************
 
700
 *                                           *
 
701
 * Interface initialisation before launching *
 
702
 *                                           *
 
703
 *********************************************/
 
704
 
 
705
void create_menus(Widget menu_bar)
 
706
{
 
707
    Widget menu;
 
708
    
 
709
    menu=make_menu("File",'F',menu_bar);
 
710
    open_option = make_menu_option("Open", 'O', MENU_OPEN, menu);
 
711
    add_accelerator(open_option, "meta+o", "Meta<Key>o:");
 
712
    
 
713
    quit_option = make_menu_option("Exit", 'E', MENU_QUIT, menu);
 
714
    add_accelerator(quit_option, "meta+q", "Meta<Key>q:");
 
715
 
 
716
    menu=make_menu("Options",'O',menu_bar);
 
717
    auto_next_option= make_menu_toggle("Auto Next", MENU_TOGGLE, menu);
 
718
    XmToggleButtonSetState( auto_next_option , True , False );
 
719
 
 
720
 
 
721
}
 
722
 
 
723
void create_dialog_boxes()
 
724
{
 
725
    Arg al[10];
 
726
    int ac;
 
727
    XmString add_all = XmStringCreateLocalized("ADD ALL");
 
728
  
 
729
    /* create the file selection box used by MENU_OPEN */
 
730
    ac=0;
 
731
    XtSetArg(al[ac],XmNmustMatch,True); ac++;
 
732
    XtSetArg(al[ac],XmNautoUnmanage,False); ac++;
 
733
    XtSetArg(al[ac],XmNdialogTitle,
 
734
             XmStringCreateLtoR("TIMIDITY: Open",char_set)); ac++;
 
735
    open_dialog=XmCreateFileSelectionDialog(toplevel,"open_dialog",al,ac);
 
736
    XtAddCallback(open_dialog, XmNokCallback, 
 
737
                  (XtCallbackProc) openCB, (XtPointer) DIALOG_OK);
 
738
    XtAddCallback(open_dialog, XmNcancelCallback, 
 
739
                  (XtCallbackProc) openCB, (XtPointer) DIALOG_CANCEL);
 
740
    XtUnmanageChild(XmFileSelectionBoxGetChild(open_dialog, XmDIALOG_HELP_BUTTON));
 
741
    
 
742
    ac = 0;
 
743
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
744
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
745
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
746
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
747
    XtSetArg(al[ac], XmNlabelString, add_all); ac++;
 
748
    add_all_button = XmCreatePushButton(open_dialog, "add_all",al, ac);
 
749
    XtManageChild(add_all_button); 
 
750
    XtAddCallback(add_all_button, XmNactivateCallback,
 
751
                  (XtCallbackProc) openCB, (XtPointer) DIALOG_ALL);
 
752
}
 
753
 
 
754
void Launch_Motif_Process(int motif_pipe_number)
 
755
{
 
756
    Arg al[20];
 
757
    int ac;
 
758
    int argc=0;
 
759
 
 
760
    /* create the toplevel shell */
 
761
    toplevel = XtAppInitialize(&context,"timidity",NULL,0,&argc,NULL,
 
762
                               NULL,NULL,0);
 
763
 
 
764
    /*******************/
 
765
    /* Main form       */
 
766
    /*******************/
 
767
    ac=0;
 
768
    XtSetArg(al[ac],XmNtopAttachment,XmATTACH_FORM); ac++;
 
769
    XtSetArg(al[ac],XmNbottomAttachment,XmATTACH_FORM); ac++;
 
770
    XtSetArg(al[ac],XmNrightAttachment,XmATTACH_FORM); ac++;
 
771
    XtSetArg(al[ac],XmNleftAttachment,XmATTACH_FORM); ac++;
 
772
    
 
773
    mainForm=XmCreateForm(toplevel,"form",al,ac);
 
774
    XtManageChild(mainForm);
 
775
 
 
776
    CreatePixmaps(mainForm); 
 
777
  
 
778
 
 
779
    /* create a menu bar and attach it to the form. */
 
780
    ac=0;
 
781
    XtSetArg(al[ac], XmNtopAttachment,   XmATTACH_FORM); ac++;
 
782
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
783
    XtSetArg(al[ac], XmNleftAttachment,  XmATTACH_FORM); ac++;
 
784
    menu_bar=XmCreateMenuBar(mainForm,"menu_bar",al,ac);
 
785
    XtManageChild(menu_bar);
 
786
    
 
787
    create_dialog_boxes();
 
788
    create_menus(menu_bar);
 
789
 
 
790
    /*******************/
 
791
    /* Message window  */
 
792
    /*******************/
 
793
    
 
794
    ac=0;
 
795
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
796
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
797
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
798
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
799
    XtSetArg(al[ac],XmNtopAttachment,XmATTACH_WIDGET); ac++;
 
800
    XtSetArg(al[ac],XmNtopWidget, menu_bar); ac++;
 
801
    XtSetArg(al[ac],XmNrightAttachment,XmATTACH_FORM); ac++;
 
802
    XtSetArg(al[ac],XmNleftAttachment,XmATTACH_FORM); ac++;
 
803
    XtSetArg(al[ac],XmNeditMode,XmMULTI_LINE_EDIT); ac++;
 
804
    XtSetArg(al[ac],XmNrows,10); ac++;
 
805
    XtSetArg(al[ac],XmNcolumns,10); ac++;
 
806
    XtSetArg(al[ac],XmNeditable, False); ac++;
 
807
    XtSetArg(al[ac],XmNwordWrap, True); ac++;
 
808
    XtSetArg(al[ac],XmNvalue, "TIMIDIY RUNNING...\n"); ac++;
 
809
    wpr_position+= strlen("TIMIDIY RUNNING...\n");
 
810
    
 
811
    text=XmCreateScrolledText(mainForm,"text",al,ac);
 
812
 
 
813
    parenttext=XtParent(text);
 
814
 
 
815
    XtManageChild(text);    
 
816
   
 
817
    /********************/ 
 
818
    /* File_name label  */
 
819
    /********************/
 
820
    ac = 0;
 
821
    XtSetArg(al[ac], XmNleftOffset, 20); ac++;
 
822
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
823
    XtSetArg(al[ac], XmNtopOffset, 20); ac++;
 
824
    XtSetArg(al[ac], XmNbottomOffset, 20); ac++;
 
825
    XtSetArg(al[ac], XmNlabelType, XmSTRING); ac++;
 
826
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
827
    /* XtSetArg(al[ac], XmNtopWidget, text); ac++; */
 
828
    XtSetArg(al[ac], XmNtopWidget, parenttext); ac++;
 
829
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_FORM); ac++;
 
830
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
831
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
832
    XtSetArg(al[ac], XmNalignment,XmALIGNMENT_END); ac++;
 
833
    XtSetArg(al[ac], XmNlabelString,
 
834
             XmStringCreate("Playing:",char_set)); ac++;
 
835
    file_headlbl = XmCreateLabel(mainForm,"fileheadlbl",al,ac);
 
836
    XtManageChild(file_headlbl);
 
837
    
 
838
 
 
839
    ac = 0;
 
840
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
841
    XtSetArg(al[ac], XmNtopOffset, 20); ac++;
 
842
    XtSetArg(al[ac], XmNbottomOffset, 20); ac++;
 
843
    XtSetArg(al[ac], XmNlabelType, XmSTRING); ac++;
 
844
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
845
    /* XtSetArg(al[ac], XmNtopWidget, text); ac++; */
 
846
    XtSetArg(al[ac], XmNtopWidget, parenttext); ac++;
 
847
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_WIDGET); ac++;
 
848
    XtSetArg(al[ac], XmNleftWidget,file_headlbl); ac++;
 
849
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
850
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
851
    XtSetArg(al[ac], XmNalignment,XmALIGNMENT_BEGINNING); ac++;
 
852
    XtSetArg(al[ac], XmNlabelString,
 
853
             XmStringCreate("NONE           ",char_set)); ac++;
 
854
    file_namelbl = XmCreateLabel(mainForm,"filenameLbl",al,ac);
 
855
    XtManageChild(file_namelbl);
 
856
 
 
857
    /*****************************/
 
858
    /* TIME LABELS IN A FORM     */
 
859
    /*****************************/
 
860
   
 
861
    /* Counters frame    */
 
862
    ac=0;
 
863
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
864
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
865
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
866
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
867
    XtSetArg(al[ac],XmNtopAttachment,XmATTACH_WIDGET); ac++;
 
868
    /* XtSetArg(al[ac],XmNtopWidget,text); ac++; */
 
869
    XtSetArg(al[ac],XmNtopWidget,parenttext); ac++;
 
870
    XtSetArg(al[ac],XmNrightAttachment,XmATTACH_FORM); ac++;
 
871
    /*
 
872
      XtSetArg(al[ac],XmNleftAttachment,XmATTACH_WIDGET); ac++;
 
873
      XtSetArg(al[ac],XmNleftWidget,file_namelbl); ac++;
 
874
      */
 
875
    XtSetArg(al[ac],XmNshadowType,XmSHADOW_OUT); ac++;
 
876
    countFrame=XmCreateFrame(mainForm,"countframe",al,ac);
 
877
    XtManageChild(countFrame);
 
878
 
 
879
    /* Counters form       */
 
880
    ac=0;
 
881
    XtSetArg(al[ac],XmNtopAttachment,XmATTACH_FORM); ac++;
 
882
    XtSetArg(al[ac],XmNbottomAttachment,XmATTACH_FORM); ac++;
 
883
    XtSetArg(al[ac],XmNrightAttachment,XmATTACH_FORM); ac++;
 
884
    XtSetArg(al[ac],XmNleftAttachment,XmATTACH_FORM); ac++;
 
885
    XtSetArg(al[ac],XmNleftAttachment,XmATTACH_FORM); ac++;
 
886
   
 
887
    countForm=XmCreateForm(countFrame,"countform",al,ac);
 
888
    XtManageChild(countForm);
 
889
     
 
890
    /* HEADER label       */
 
891
    ac = 0;
 
892
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
893
    XtSetArg(al[ac], XmNlabelType, XmSTRING); ac++;
 
894
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
895
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_FORM); ac++;
 
896
    XtSetArg(al[ac], XmNrightAttachment,XmATTACH_FORM); ac++;
 
897
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
898
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
899
    XtSetArg(al[ac], XmNlabelString,
 
900
             XmStringCreate("Tempus Fugit",char_set)); ac++;
 
901
    count_headlbl = XmCreateLabel(countForm,"countheadLbl",al,ac);
 
902
    XtManageChild(count_headlbl);
 
903
 
 
904
    /* current Time label       */
 
905
    ac = 0;
 
906
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
907
    XtSetArg(al[ac], XmNtopWidget, count_headlbl); ac++;
 
908
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_FORM); ac++;
 
909
    XtSetArg(al[ac], XmNbottomAttachment,XmATTACH_FORM); ac++;
 
910
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
911
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
912
    XtSetArg(al[ac], XmNalignment,XmALIGNMENT_END); ac++;
 
913
    XtSetArg(al[ac], XmNlabelString,
 
914
             XmStringCreate("00:00",char_set)); ac++;
 
915
    counterlbl = XmCreateLabel(countForm,"counterLbl",al,ac);
 
916
    XtManageChild(counterlbl);
 
917
    
 
918
    /* Total time label */
 
919
        
 
920
    ac = 0;
 
921
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
922
    XtSetArg(al[ac], XmNtopWidget, count_headlbl); ac++;
 
923
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
924
    XtSetArg(al[ac], XmNleftWidget, counterlbl); ac++;
 
925
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
926
    XtSetArg(al[ac], XmNbottomAttachment,XmATTACH_FORM); ac++;
 
927
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
928
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
929
    XtSetArg(al[ac], XmNalignment,XmALIGNMENT_BEGINNING); ac++;
 
930
    XtSetArg(al[ac], XmNlabelString,
 
931
             XmStringCreate("/ 00:00",char_set)); ac++;
 
932
    totlbl = XmCreateLabel(countForm,"TotalTimeLbl",al,ac);
 
933
    XtManageChild(totlbl);
 
934
            
 
935
    /******************/ 
 
936
    /* Locator Scale  */
 
937
    /******************/
 
938
    {   /*
 
939
         * We need to add an xevent manager for buton pressing since 
 
940
         * locator_scale is a critical ressource that can be modified
 
941
         * by shared by the handle input function
 
942
         */
 
943
 
 
944
        WidgetList WList;
 
945
        Cardinal Card;
 
946
 
 
947
        ac = 0;
 
948
        XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
949
        XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
950
        XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
951
        XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
952
        XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
953
        /* XtSetArg(al[ac], XmNtopWidget, countForm); ac++; */
 
954
        XtSetArg(al[ac], XmNtopWidget, countFrame); ac++;
 
955
        XtSetArg(al[ac], XmNleftAttachment,XmATTACH_FORM); ac++;
 
956
        XtSetArg(al[ac], XmNrightAttachment,XmATTACH_FORM); ac++;
 
957
        XtSetArg(al[ac], XmNmaximum, 100); ac++;
 
958
        XtSetArg(al[ac], XmNminimum, 0); ac++;
 
959
        XtSetArg(al[ac], XmNshowValue, True); ac++;
 
960
        XtSetArg(al[ac], XmNdecimalPoints, 2); ac++;
 
961
        XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
 
962
        XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
963
        XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
964
        locator_scale = XmCreateScale(mainForm,"locator",al,ac);
 
965
        XtManageChild(locator_scale);
 
966
        XtAddCallback(locator_scale,XmNvalueChangedCallback,
 
967
                      (XtCallbackProc) Generic_scaleCB, 
 
968
                      (XtPointer) MOTIF_CHANGE_LOCATOR);
 
969
        
 
970
        /* Reach the scrollbar child in the scale  */
 
971
        ac = 0;
 
972
        XtSetArg(al[ac], XtNchildren, &WList); ac++;    
 
973
        XtSetArg(al[ac], XtNnumChildren, &Card); ac++;  
 
974
        XtGetValues(locator_scale,al,ac);    
 
975
        if ((Card!=2)||
 
976
            strcmp(XtName(WList[1]),"Scrollbar"))
 
977
            fprintf(stderr,"PANIC: Scale has be redefined.. may cause bugs\n");
 
978
        
 
979
        XtAddEventHandler(WList[1],ButtonPressMask|ButtonReleaseMask,
 
980
                          FALSE,Locator_btn,NULL);
 
981
    }
 
982
 
 
983
    /*****************************/
 
984
    /* Control buttons in a form */
 
985
    /*****************************/
 
986
    
 
987
    /* create form for the row of control buttons */
 
988
    ac = 0; 
 
989
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
990
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
991
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
992
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
993
    XtSetArg(al[ac],XmNtopAttachment,XmATTACH_WIDGET); ac++;
 
994
    XtSetArg(al[ac], XmNtopWidget, locator_scale); ac++;
 
995
    btnForm = XmCreateForm(mainForm,"btnForm", al, ac);
 
996
    XtManageChild(btnForm);
 
997
    
 
998
    /* Previous Button */
 
999
    ac = 0;
 
1000
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1001
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
 
1002
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
1003
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1004
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1005
    XtSetArg(al[ac], XmNlabelPixmap, prevPixmap); ac++;
 
1006
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1007
    prevBtn = XmCreatePushButton(btnForm, "previous",al, ac);
 
1008
    XtManageChild(prevBtn);
 
1009
    XtAddCallback(prevBtn, XmNactivateCallback,
 
1010
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_PREV);
 
1011
 
 
1012
 
 
1013
    /* Backward Button */
 
1014
    ac = 0;
 
1015
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1016
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1017
    XtSetArg(al[ac], XmNleftWidget, prevBtn); ac++;
 
1018
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
1019
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1020
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1021
    XtSetArg(al[ac], XmNlabelPixmap, backPixmap); ac++;
 
1022
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1023
    backBtn = XmCreatePushButton(btnForm, "backward",al, ac);
 
1024
    XtManageChild(backBtn);
 
1025
    XtAddCallback(backBtn, XmNactivateCallback,
 
1026
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_RWD);
 
1027
 
 
1028
    /* Restart Button */
 
1029
    ac = 0;
 
1030
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1031
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1032
    XtSetArg(al[ac], XmNleftWidget, backBtn); ac++;
 
1033
    XtSetArg(al[ac], XmNleftOffset, 2); ac++;
 
1034
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1035
    XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
 
1036
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1037
    XtSetArg(al[ac], XmNlabelPixmap, restartPixmap); ac++;
 
1038
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1039
    restartBtn = XmCreatePushButton(btnForm,"restartBtn", al, ac);
 
1040
    XtManageChild(restartBtn);
 
1041
    XtAddCallback(restartBtn, XmNactivateCallback,
 
1042
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_RESTART);
 
1043
 
 
1044
    /* Quit Button */
 
1045
    ac = 0;
 
1046
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1047
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1048
    XtSetArg(al[ac], XmNleftWidget, restartBtn); ac++;
 
1049
    XtSetArg(al[ac], XmNleftOffset, 2); ac++;
 
1050
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1051
    XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
 
1052
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1053
    XtSetArg(al[ac], XmNlabelPixmap, quitPixmap); ac++;
 
1054
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1055
    quitBtn = XmCreatePushButton(btnForm,"quitBtn", al, ac);
 
1056
    XtManageChild(quitBtn);
 
1057
    XtAddCallback(quitBtn, XmNactivateCallback,
 
1058
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_QUIT);
 
1059
 
 
1060
    /* Pause Button */
 
1061
 
 
1062
    ac = 0;
 
1063
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1064
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1065
    XtSetArg(al[ac], XmNleftWidget, quitBtn); ac++;
 
1066
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1067
    XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
 
1068
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1069
    XtSetArg(al[ac], XmNlabelPixmap, pausePixmap); ac++;
 
1070
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1071
    pauseBtn =  XmCreatePushButton(btnForm,"pauseBtn", al, ac);
 
1072
    XtManageChild(pauseBtn);
 
1073
    XtAddCallback(pauseBtn, XmNactivateCallback,
 
1074
                  (XtCallbackProc) GenericCB,(XtPointer) MOTIF_PAUSE);
 
1075
 
 
1076
    /* Forward Button */
 
1077
 
 
1078
    ac = 0;
 
1079
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1080
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1081
    XtSetArg(al[ac], XmNleftWidget,pauseBtn); ac++;
 
1082
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1083
    XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
 
1084
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1085
    XtSetArg(al[ac], XmNlabelPixmap, fwdPixmap); ac++;
 
1086
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1087
    fwdBtn =  XmCreatePushButton(btnForm,"fwdBtn", al, ac);
 
1088
    XtManageChild(fwdBtn);
 
1089
    XtAddCallback(fwdBtn, XmNactivateCallback,
 
1090
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_FWD);
 
1091
 
 
1092
    /* Next Button */
 
1093
    ac = 0;
 
1094
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
 
1095
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
1096
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
 
1097
    XtSetArg(al[ac], XmNleftWidget, fwdBtn); ac++;
 
1098
    XtSetArg(al[ac], XmNleftOffset, 2); ac++;
 
1099
    XtSetArg(al[ac], XmNshadowType, XmSHADOW_OUT); ac++;
 
1100
    XtSetArg(al[ac], XmNshadowThickness, 2); ac++;
 
1101
    XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
 
1102
    XtSetArg(al[ac], XmNlabelPixmap, nextPixmap); ac++;
 
1103
    XtSetArg(al[ac], XmNhighlightThickness, 2); ac++;
 
1104
    nextBtn = XmCreatePushButton(btnForm,"nextBtn", al, ac);
 
1105
    XtManageChild(nextBtn);
 
1106
    XtAddCallback(nextBtn, XmNactivateCallback,
 
1107
                  (XtCallbackProc) GenericCB, (XtPointer) MOTIF_NEXT);
 
1108
    
 
1109
    /********************/
 
1110
    /* Volume scale     */
 
1111
    /********************/
 
1112
    ac = 0;
 
1113
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
1114
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
1115
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
1116
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
1117
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
1118
    XtSetArg(al[ac], XmNtopWidget, btnForm); ac++;
 
1119
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_FORM); ac++;
 
1120
    XtSetArg(al[ac], XmNbottomAttachment,XmATTACH_FORM); ac++;
 
1121
 
 
1122
    XtSetArg(al[ac], XmNmaximum, MAX_AMPLIFICATION); ac++;
 
1123
    XtSetArg(al[ac], XmNminimum, 0); ac++;
 
1124
    XtSetArg(al[ac], XmNshowValue, True); ac++;
 
1125
 
 
1126
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
1127
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
1128
    XtSetArg(al[ac], XmNtitleString,
 
1129
             XmStringCreate("VOL",char_set)); ac++;
 
1130
    volume_scale = XmCreateScale(mainForm,"volscale",al,ac);
 
1131
    XtManageChild(volume_scale);
 
1132
    XtAddCallback(volume_scale, XmNvalueChangedCallback,
 
1133
                  (XtCallbackProc) Generic_scaleCB,
 
1134
                  (XtPointer) MOTIF_CHANGE_VOLUME);
 
1135
  
 
1136
  
 
1137
    /********************/ 
 
1138
    /* File list        */
 
1139
    /********************/ 
 
1140
    
 
1141
    ac = 0;
 
1142
    XtSetArg(al[ac], XmNtopOffset, 10); ac++;
 
1143
    XtSetArg(al[ac], XmNbottomOffset, 10); ac++;
 
1144
    XtSetArg(al[ac], XmNleftOffset, 10); ac++;
 
1145
    XtSetArg(al[ac], XmNrightOffset, 10); ac++;
 
1146
    XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
 
1147
    XtSetArg(al[ac], XmNtopWidget, btnForm ); ac++;
 
1148
    XtSetArg(al[ac], XmNleftAttachment,XmATTACH_WIDGET); ac++;
 
1149
    XtSetArg(al[ac], XmNleftWidget, volume_scale); ac++;
 
1150
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
 
1151
    XtSetArg(al[ac], XmNbottomAttachment,XmATTACH_FORM); ac++;
 
1152
 
 
1153
    XtSetArg(al[ac], XmNselectionPolicy ,XmSINGLE_SELECT); ac++;
 
1154
    XtSetArg(al[ac], XmNscrollBarDisplayPolicy ,XmAS_NEEDED); ac++;
 
1155
    XtSetArg(al[ac], XmNlistSizePolicy ,XmRESIZE_IF_POSSIBLE); ac++;
 
1156
 
 
1157
    XtSetArg(al[ac], XmNtraversalOn, False); ac++;
 
1158
    XtSetArg(al[ac], XmNhighlightThickness,0); ac++;
 
1159
   
 
1160
    file_list = XmCreateScrolledList(mainForm,"File List",al,ac);
 
1161
    XtManageChild(file_list);
 
1162
    XtAddCallback(file_list, XmNsingleSelectionCallback,
 
1163
                  (XtCallbackProc) File_ListCB,
 
1164
                  NULL);
 
1165
 
 
1166
    /*
 
1167
     * Last details on toplevel
 
1168
     */
 
1169
    ac=0;
 
1170
    /*
 
1171
      XtSetArg(al[ac],XmNwidth,400); ac++;
 
1172
      XtSetArg(al[ac],XmNheight,800); ac++;
 
1173
      */
 
1174
    XtSetArg(al[ac], XmNtitle, "Timidity 6.4f"); ac++;
 
1175
    XtSetArg(al[ac], XmNiconName, "NONE"); ac++;
 
1176
    XtSetArg(al[ac], XmNiconPixmap, timidityPixmap); ac++; 
 
1177
    XtSetValues(toplevel,al,ac);
 
1178
    
 
1179
        
 
1180
  /*******************************************************/ 
 
1181
  /* Plug the pipe ..... and heeere we go                */
 
1182
  /*******************************************************/ 
 
1183
 
 
1184
    XtAppAddInput(context,motif_pipe_number, 
 
1185
                  (XtPointer) XtInputReadMask,handle_input,NULL);
 
1186
    
 
1187
    XtRealizeWidget(toplevel);
 
1188
    XtAppMainLoop(context);
 
1189
}
 
1190
#endif /* IA_MOTIF */