← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to src/xt_options.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-25 15:47:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080225154712-qvr11ekcea4c9ry8
Tags: 1.1.6-0.1ubuntu1
https://launchpad.net/bugs/120003
* Merge from debian-multimedia (LP: #120003), Ubuntu Changes:
 - For ffmpeg-related build-deps, remove cvs from package names.
 - Standards-Version 3.7.3
 - Maintainer Spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xt_options.c
1
 
/*
2
 
 * xt_options.c
3
 
 *
4
 
 * Copyright (C) 1997,98 Rasca, Berlin
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
 
 *
21
 
 * This file contains the Xt GUI's options dialog
22
 
 *
23
 
 */
24
 
 
25
 
#include "../config.h"  /* autoconf output */
26
 
 
27
 
#include <stdio.h>
28
 
#include <stdlib.h>
29
 
#include <limits.h>
30
 
#include <X11/Intrinsic.h>
31
 
#include <X11/StringDefs.h>
32
 
#include <X11/Shell.h>
33
 
#include "Xw/Label.h"
34
 
#include "Xw/Box.h"
35
 
#include "Xw/Field.h"
36
 
#include "Xw/Button.h"
37
 
#include "Xw/Toggle.h"
38
 
#include "xt_options.h"
39
 
#include "job.h"
40
 
#include "xutil.h"
41
 
#include "app_data.h"
42
 
 
43
 
#define DLG_CANCEL      0
44
 
#define DLG_OK          1
45
 
#define DLG_SAVE        2
46
 
 
47
 
static Widget wShell, wFps, wFile, wMaxFrames, wMaxTime, wQuality;
48
 
static Widget wCompress, wCodec, wShm, wMouse, wMouseType;
49
 
extern Widget next, prev;
50
 
static Job *sJob;
51
 
 
52
 
void ChangeLabel (int pic_no);
53
 
static void CbOk (Widget w, XtPointer client_data, XtPointer call_data);
54
 
static void CbSave (Widget w, XtPointer client_data, XtPointer call_data);
55
 
static void CbCancel (Widget w, XtPointer client_data, XtPointer call_data);
56
 
static void CbActivate (Widget w, XtPointer client_data, XtPointer call_data);
57
 
 
58
 
 
59
 
/*
60
 
 * read the new values and close the window
61
 
 */
62
 
static void
63
 
CbOk (Widget w, XtPointer client_data, XtPointer call_data)
64
 
{
65
 
#include "codecs.h"
66
 
 
67
 
        char *str;
68
 
        int val_int;
69
 
        float val_float;
70
 
        Job *job = (Job *) sJob;
71
 
 
72
 
        str = XwFieldGetString (wQuality);
73
 
        if ( str ) {
74
 
                if ( *str ) {
75
 
                        val_int = job_quality ();
76
 
                        sscanf (str, "%d", &val_int);
77
 
                        job_set_quality (val_int);
78
 
                }
79
 
                free (str);
80
 
        }
81
 
 
82
 
        str = XwFieldGetString (wCompress);
83
 
        if ( str ) {
84
 
                if ( *str ) {
85
 
                        val_int = job_compression ();
86
 
                        sscanf (str, "%d", &val_int);
87
 
                        job_set_compression (val_int);
88
 
                }
89
 
                free (str);
90
 
        }
91
 
 
92
 
        str = XwFieldGetString (wFps);
93
 
        if (str) {
94
 
                if (*str) {
95
 
                        val_float = job_fps ();
96
 
                        sscanf (str, "%f", &val_float);
97
 
                        job_set_fps (val_float);
98
 
                }
99
 
                free (str);
100
 
        }
101
 
 
102
 
        str = XwFieldGetString (wFile);
103
 
        if (str) {
104
 
                if (*str) {
105
 
                        job_set_file (str);
106
 
                }
107
 
                free (str);
108
 
        }
109
 
 
110
 
        str = XwFieldGetString (wMaxFrames);
111
 
        if (str) {
112
 
                if (*str)
113
 
                        sscanf (str, "%d", &job->max_frames);
114
 
                free (str);
115
 
        }
116
 
 
117
 
        str = XwFieldGetString (wMaxTime);
118
 
        if (str) {
119
 
                if (*str)
120
 
                        sscanf (str, "%f", &job->max_time);
121
 
                free (str);
122
 
        }
123
 
 
124
 
        str = XwFieldGetString (wCodec);
125
 
        if (str) {
126
 
                if (*str) {
127
 
                        int i, a = -1;
128
 
                        Boolean found = FALSE;
129
 
 
130
 
                        for  (i = 0; i < NUMCODECS; i ++) {
131
 
                                if (strcmp(tCodecNames[i], str) == 0) a = i;
132
 
                        }
133
 
                        if (a < CODEC_MPEG1) {
134
 
                                a = CODEC_MPEG1;
135
 
                                fprintf(stderr, "Unsupported Codec selected, resetting to MPEG1!\n");
136
 
                        }
137
 
                        job->targetCodec = a;
138
 
                }
139
 
                free (str);
140
 
        }
141
 
 
142
 
#ifdef HAVE_SHMAT
143
 
        XtVaGetValues (wShm, XtNstate, &val_int, NULL);
144
 
        if (val_int) {
145
 
                job->flags |= FLG_USE_SHM;
146
 
                job_set_capture ();
147
 
        } else {
148
 
                job->flags &= ~FLG_USE_SHM;
149
 
                job_set_capture ();
150
 
        }
151
 
#endif
152
 
        XtVaGetValues (wMouse, XtNstate, &val_int, NULL);
153
 
        if (val_int) {
154
 
                XtVaGetValues (wMouseType, XtNstate, &val_int, NULL);
155
 
                if (val_int) {
156
 
                        job->mouseWanted = 2;
157
 
                } else {
158
 
                        job->mouseWanted = 1;
159
 
                }
160
 
        } else {
161
 
                job->mouseWanted = 0;
162
 
        }
163
 
 
164
 
        XtDestroyWidget (wShell);
165
 
        ChangeLabel (job->pic_no);
166
 
 
167
 
        // unset autocontinue unless we capture to movie and file is mutable
168
 
        if ( job->flags & FLG_AUTO_CONTINUE && ( (! is_filename_mutable(job->file)) ||
169
 
                (! job->flags & FLG_MULTI_IMAGE) ) ) {
170
 
            job->flags &= ~FLG_AUTO_CONTINUE;
171
 
            fprintf(stderr, "Output not a video file or no counter in filename\nDisabling autocontinue!\n");
172
 
        }
173
 
        
174
 
    /* previous and next buttons have different meanings for on-the-fly encoding
175
 
     * and individual frame capture */
176
 
    if (( job->flags & FLG_MULTI_IMAGE ) == 0 ) {
177
 
        if (job->pic_no > job->step ) XtSetSensitive(prev, True);
178
 
        else XtSetSensitive(prev, False);
179
 
    } else {
180
 
        if ( is_filename_mutable(job->file) ) {
181
 
            XtSetSensitive(next, True);    
182
 
            XtSetSensitive(prev, True);    
183
 
        } else {
184
 
            XtSetSensitive(next, False);    
185
 
            if (job->movie_no > 0 ) XtSetSensitive(prev, True);    
186
 
            else XtSetSensitive(prev, False);    
187
 
        }
188
 
    }
189
 
        
190
 
}
191
 
 
192
 
/*
193
 
 * save the values
194
 
 */
195
 
static void
196
 
CbSave (Widget w, XtPointer client_data, XtPointer call_data)
197
 
{
198
 
 
199
 
#include "codecs.h"
200
 
 
201
 
        char *str;
202
 
        int val_int;
203
 
        float val_float;
204
 
        char *home;
205
 
        char file[PATH_MAX+1];
206
 
        FILE *fp;
207
 
        Job *job = (Job *) sJob ;
208
 
 
209
 
        str = XwFieldGetString (wQuality);
210
 
        if ( str ) {
211
 
                if ( *str ) {
212
 
                        val_int = job_quality ();
213
 
                        sscanf (str, "%d", &val_int);
214
 
                        job_set_quality (val_int);
215
 
                }
216
 
                free (str);
217
 
        }
218
 
 
219
 
        str = XwFieldGetString (wCompress);
220
 
        if ( str ) {
221
 
                if ( *str ) {
222
 
                        val_int = job_compression ();
223
 
                        sscanf (str, "%d", &val_int);
224
 
                        job_set_compression (val_int);
225
 
                }
226
 
                free (str);
227
 
        }
228
 
 
229
 
        str = XwFieldGetString (wFps);
230
 
        if (str) {
231
 
                if (*str) {
232
 
                        val_float = job_fps ();
233
 
                        sscanf (str, "%f", &val_float);
234
 
                        job_set_fps (val_float);
235
 
                }
236
 
                free (str);
237
 
        }
238
 
 
239
 
        str = XwFieldGetString (wFile);
240
 
        if (str) {
241
 
                if (*str) {
242
 
                        job_set_file (str);
243
 
                }
244
 
                free (str);
245
 
        }
246
 
 
247
 
        str = XwFieldGetString (wMaxFrames);
248
 
        if (str) {
249
 
                if (*str)
250
 
                        sscanf (str, "%d", &job->max_frames);
251
 
                free (str);
252
 
        }
253
 
 
254
 
        str = XwFieldGetString (wMaxTime);
255
 
        if (str) {
256
 
                if (*str)
257
 
                        sscanf (str, "%f", &job->max_time);
258
 
                free (str);
259
 
        }
260
 
 
261
 
        str = XwFieldGetString (wCodec);
262
 
        if (str) {
263
 
                if (*str) {
264
 
                        int i, a = -1;
265
 
                        Boolean found = FALSE;
266
 
 
267
 
                        for  (i = 0; i < NUMCODECS; i ++) {
268
 
                                if (strcmp(tCodecNames[i], str) == 0) a = i;
269
 
                        }
270
 
                        if (a < CODEC_MPEG1) {
271
 
                                a = CODEC_MPEG1;
272
 
                                fprintf(stderr, "Unsupported Codec selected, resetting to MPEG1!\n");
273
 
                        }
274
 
                        job->targetCodec = a;
275
 
                }
276
 
                free (str);
277
 
        }
278
 
 
279
 
#ifdef HAVE_SHMAT
280
 
        XtVaGetValues (wShm, XtNstate, &val_int, NULL);
281
 
        if (val_int) {
282
 
                job->flags |= FLG_USE_SHM;
283
 
                job_set_capture ();
284
 
        } else {
285
 
                job->flags &= ~FLG_USE_SHM;
286
 
                job_set_capture ();
287
 
        }
288
 
#endif
289
 
        XtVaGetValues (wMouse, XtNstate, &val_int, NULL);
290
 
        if (val_int) {
291
 
                XtVaGetValues (wMouseType, XtNstate, &val_int, NULL);
292
 
                if (val_int) {
293
 
                        job->mouseWanted = 2;
294
 
                } else {
295
 
                        job->mouseWanted = 1;
296
 
                }
297
 
        } else {
298
 
                job->mouseWanted = 0;
299
 
        }
300
 
 
301
 
        if ( ! XVC_WriteOptionsFile(job) ) {
302
 
            fprintf(stderr, "Unable to write personal options file!\n");
303
 
        }
304
 
}
305
 
 
306
 
/*
307
 
 */
308
 
static void
309
 
CbCancel (Widget w, XtPointer client_data, XtPointer call_data)
310
 
{
311
 
        XtDestroyWidget (wShell);
312
 
}
313
 
 
314
 
/*
315
 
 */
316
 
static void
317
 
CbActivate (Widget w, XtPointer client_data, XtPointer call_data)
318
 
{
319
 
        static Time t = CurrentTime;
320
 
        Widget next = (Widget) client_data;
321
 
 
322
 
#ifdef DEBUG
323
 
        printf ("%s: CbActivate()\n", __FILE__);
324
 
#endif
325
 
        if (XtCallAcceptFocus (next, &t))
326
 
                XtSetKeyboardFocus (XtParent(w), next);
327
 
}
328
 
 
329
 
 
330
 
/*
331
 
 * create the options dialog window
332
 
 */
333
 
void
334
 
CbOptions (Widget w, XtPointer client_data, XtPointer call_data)
335
 
{
336
 
#include "codecs.h"
337
 
 
338
 
        Job *job = (Job *) client_data;
339
 
        Widget frame, box, info;
340
 
        Widget fps_lbl, file_lbl, max_frames_lbl, max_time_lbl, quality_lbl;
341
 
        Widget compress_lbl, codec_lbl, mouse_lbl, ok, cancel, save;
342
 
        Position x, y;
343
 
        char str[PATH_MAX+1];
344
 
 
345
 
        sJob = job;
346
 
#ifdef DEBUG
347
 
        printf ("CbOptions() fps=%f\n", job->fps);
348
 
#endif
349
 
        wShell = XtVaCreatePopupShell ("options", transientShellWidgetClass,
350
 
                                GetToplevel(w), XtNinput, TRUE, NULL);
351
 
        frame = XtVaCreateManagedWidget ("frame", xwBoxWidgetClass, wShell, NULL);
352
 
 
353
 
        info = XtVaCreateManagedWidget ("info", xwLabelWidgetClass, frame,
354
 
                                        XtNshadowType, XtShadowNone, NULL);
355
 
 
356
 
        sprintf (str, "%f", job->fps);
357
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
358
 
                        XtNorientation, XtorientHorizontal, NULL);
359
 
        wFps = XtVaCreateManagedWidget ("fps_val", xwFieldWidgetClass, box,
360
 
                                        XtNstring, str, XtNonlyNumber, True, NULL);
361
 
        fps_lbl =XtVaCreateManagedWidget ("fps", xwLabelWidgetClass, box, NULL);
362
 
 
363
 
        sprintf (str, "%s", job->file);
364
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
365
 
                        XtNorientation, XtorientHorizontal, NULL);
366
 
        wFile = XtVaCreateManagedWidget ("file_val", xwFieldWidgetClass, box,
367
 
                                        XtNstring, str, XtNprev, wFps, NULL);
368
 
        file_lbl =XtVaCreateManagedWidget ("file", xwLabelWidgetClass, box, NULL);
369
 
 
370
 
        sprintf (str, "%d", job->max_frames);
371
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
372
 
                        XtNorientation, XtorientHorizontal, NULL);
373
 
        wMaxFrames = XtVaCreateManagedWidget ("max_frames_val", xwFieldWidgetClass,
374
 
                                        box, XtNstring, str, XtNonlyNumber, True,
375
 
                                        XtNprev, wFile, NULL);
376
 
        max_frames_lbl = XtVaCreateManagedWidget ("max_frames", xwLabelWidgetClass,
377
 
                                        box, NULL);
378
 
 
379
 
        sprintf (str, "%f", job->max_time);
380
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
381
 
                        XtNorientation, XtorientHorizontal, NULL);
382
 
        wMaxTime = XtVaCreateManagedWidget ("max_time_val", xwFieldWidgetClass,
383
 
                                        box, XtNstring, str, XtNonlyNumber, True,
384
 
                                        XtNprev, wMaxFrames, NULL);
385
 
        max_time_lbl =XtVaCreateManagedWidget ("max_time", xwLabelWidgetClass,
386
 
                                        box, NULL);
387
 
 
388
 
        sprintf (str, "%d", job->quality);
389
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
390
 
                        XtNorientation, XtorientHorizontal, NULL);
391
 
        wQuality = XtVaCreateManagedWidget ("quality_val", xwFieldWidgetClass,
392
 
                                        box, XtNstring, str, XtNonlyNumber, True,
393
 
                                        XtNlength, 3, XtNprev, wMaxTime, NULL);
394
 
        quality_lbl = XtVaCreateManagedWidget ("quality", xwLabelWidgetClass, box,
395
 
                                        NULL);
396
 
 
397
 
 
398
 
        sprintf (str, "%d", job->compress);
399
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
400
 
                        XtNorientation, XtorientHorizontal, NULL);
401
 
        wCompress = XtVaCreateManagedWidget ("compress_val", xwFieldWidgetClass,
402
 
                                        box, XtNstring, str, XtNlength, 1,
403
 
                                        XtNonlyNumber, True, XtNprev, wQuality, NULL);
404
 
        compress_lbl = XtVaCreateManagedWidget ("compress", xwLabelWidgetClass,
405
 
                                        box, NULL);
406
 
 
407
 
        sprintf (str, "%s", tCodecNames[(job->targetCodec)]);
408
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
409
 
                        XtNorientation, XtorientHorizontal, NULL);
410
 
        wCodec = XtVaCreateManagedWidget ("codec_val", xwFieldWidgetClass,
411
 
                                        box, XtNstring, str, XtNprev, wCompress, NULL);
412
 
        codec_lbl = XtVaCreateManagedWidget ("codec (e.g. MPEG4)", xwLabelWidgetClass,
413
 
                                        box, NULL);
414
 
 
415
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
416
 
                        XtNorientation, XtorientHorizontal, NULL);
417
 
        wShm = XtVaCreateManagedWidget ("shm", xwToggleWidgetClass, box,
418
 
                                        XtNstate, (Boolean)(job->flags & FLG_USE_SHM ? 1:0),
419
 
                                        XtNprev, wCodec, NULL);
420
 
 
421
 
        wMouse = XtVaCreateManagedWidget ("mouse", xwToggleWidgetClass, box,
422
 
                                        XtNstate, (Boolean)((job->mouseWanted > 0) ? 1:0),
423
 
                                        XtNprev, wShm, NULL);
424
 
 
425
 
        wMouseType = XtVaCreateManagedWidget ("black", xwToggleWidgetClass, box,
426
 
                                        XtNstate, (Boolean)((job->mouseWanted > 1) ? 1:0),
427
 
                                        XtNprev, wMouse, NULL);
428
 
 
429
 
 
430
 
        /*
431
 
         */
432
 
        box = XtVaCreateManagedWidget ("box", xwBoxWidgetClass, frame,
433
 
                        XtNorientation, XtorientHorizontal, NULL);
434
 
        ok = XtVaCreateManagedWidget ("ok", xwButtonWidgetClass, box,
435
 
                                XtNprev, wShm, NULL);
436
 
        cancel = XtVaCreateManagedWidget ("cancel", xwButtonWidgetClass, box,
437
 
                                XtNprev, ok, NULL);
438
 
        save = XtVaCreateManagedWidget ("save", xwButtonWidgetClass, box,
439
 
                                XtNprev, cancel, XtNnext, wFps, NULL);
440
 
 
441
 
        XtVaSetValues (cancel, XtNnext, save, NULL);
442
 
        XtVaSetValues (ok, XtNnext, cancel, NULL);
443
 
        XtVaSetValues (wShm, XtNnext, ok, NULL);
444
 
        XtVaSetValues (wCompress, XtNnext, wShm, NULL);
445
 
        XtVaSetValues (wQuality, XtNnext, wCompress, NULL);
446
 
        XtVaSetValues (wMaxTime, XtNnext, wQuality, NULL);
447
 
        XtVaSetValues (wMaxFrames, XtNnext, wMaxTime, NULL);
448
 
        XtVaSetValues (wFile, XtNnext, wMaxFrames, NULL);
449
 
        XtVaSetValues (wFps, XtNnext, wFile, XtNprev, save, NULL);
450
 
 
451
 
        XtAddCallback (wFps, XtNactivateCallback, CbActivate, wFile);
452
 
        XtAddCallback (wFile, XtNactivateCallback, CbActivate, wMaxFrames);
453
 
        XtAddCallback (wMaxFrames, XtNactivateCallback, CbActivate, wMaxTime);
454
 
        XtAddCallback (wMaxTime, XtNactivateCallback, CbActivate, wQuality);
455
 
        XtAddCallback (wQuality, XtNactivateCallback, CbActivate, wCompress);
456
 
        XtAddCallback (wCompress, XtNactivateCallback, CbActivate, wShm);
457
 
 
458
 
        XtAddCallback (ok, XtNcallback, CbOk, job);
459
 
        XtAddCallback (cancel, XtNcallback, CbCancel, NULL);
460
 
        XtAddCallback (save, XtNcallback, CbSave, job);
461
 
 
462
 
        XtTranslateCoords (w, 0, 0, &x, &y);
463
 
        XtVaSetValues (wShell, XtNx, x, XtNy, y, NULL);
464
 
 
465
 
        XtPopup (wShell, XtGrabNonexclusive);
466
 
}
467
 
 
468
 
/*
469
 
 */
470
 
void
471
 
OptionDoneAction (Widget w, XEvent *ev, String *parms, Cardinal *num_parms)
472
 
{
473
 
        if (*num_parms) {
474
 
                if (*parms[0] == '1') {
475
 
                        CbOk (w, (XtPointer)DLG_OK, NULL);
476
 
                } else if (*parms[0] == '2') {
477
 
                        CbSave (w, (XtPointer)DLG_SAVE, NULL);
478
 
                } else {
479
 
                        CbCancel (w, NULL, NULL);
480
 
                }
481
 
        }
482
 
}
483
 
 
484
 
/*
485
 
 */
486
 
void
487
 
OptionOpenAction (Widget w, XEvent *ev, String *parms, Cardinal *num_parms)
488
 
{
489
 
        Job *job = job_ptr();
490
 
        CbOptions (w, (XtPointer) job, (XtPointer) NULL);
491
 
}