param.c

Revision 691, 21.3 kB (checked in by erikd, 2 years ago)

Remove needless #defines of buffer lengths.

Code had many instances of:

#undef BUF_LEN
#define BUF_LEN 64
char buf[BUF_LEN];
snprintf (buf, BUF_LEN, ....);

which can be replaced with:

char buf[64];
snprintf (buf, sizeof (buf), ....);

which is far cleaner and more difficult to get wrong.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

Line
1	/*
2	* Sweep, a sound wave editor.
3	*
4	* Copyright (C) 2000 Conrad Parker
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	*/
20
21	#ifdef HAVE_CONFIG_H
22	# include <config.h>
23	#endif
24
25	#include <stdio.h>
26	#include <string.h>
27	#include <math.h>
28
29	#include <sweep/sweep_i18n.h>
30	#include <sweep/sweep_types.h>
31	#include "sweep_app.h"
32	#include "interface.h"
33
34	#include "../pixmaps/ladlogo.xpm"
35
36	extern GtkStyle * style_bw;
37
38	static gint
39	param_cmp (sw_param_type type, sw_param p1, sw_param p2)
40	{
41	switch (type) {
42	case SWEEP_TYPE_BOOL:
43	if (p1.b == p2.b) return 0;
44	if (p2.b) return -1;
45	if (p1.b) return 1;
46	break;
47	case SWEEP_TYPE_INT:
48	if (p1.i == p2.i) return 0;
49	if (p1.i < p2.i) return -1;
50	if (p1.i > p2.i) return 1;
51	break;
52	case SWEEP_TYPE_FLOAT:
53	if (p1.f == p2.f) return 0;
54	if (p1.f < p2.f) return -1;
55	if (p1.f > p2.f) return 1;
56	break;
57	case SWEEP_TYPE_STRING:
58	return strcmp (p1.s, p2.s);
59	break;
60	default:
61	return -1;
62	break;
63	}
64
65	return -1;
66	}
67
68	/*
69	* param_copy (p1, p2)
70	*
71	* src: p1
72	* dest: p2
73	*/
74	static void
75	param_copy (sw_param * p1, sw_param * p2)
76	{
77	if (p1 == p2) return;
78	memcpy (p2, p1, sizeof (sw_param));
79	}
80
81	sw_param *
82	sw_param_set_new (sw_procedure * proc)
83	{
84	sw_param * p;
85
86	p = g_malloc0 (sizeof(sw_param) * proc->nr_params);
87
88	return p;
89	}
90
91	static void
92	print_type (sw_param_type type)
93	{
94	switch (type) {
95	case SWEEP_TYPE_BOOL:
96	printf ("SWEEP_TYPE_BOOL");
97	break;
98	case SWEEP_TYPE_INT:
99	printf ("SWEEP_TYPE_INT");
100	break;
101	case SWEEP_TYPE_FLOAT:
102	printf ("SWEEP_TYPE_FLOAT");
103	break;
104	case SWEEP_TYPE_STRING:
105	printf ("SWEEP_TYPE_STRING");
106	break;
107	default:
108	break;
109	}
110	}
111
112	static void
113	snprint_param (gchar * s, gint n, sw_param_type type, sw_param p)
114	{
115	switch (type) {
116	case SWEEP_TYPE_BOOL:
117	if (p.b) snprintf (s, n, _("TRUE"));
118	else snprintf (s, n, _("FALSE"));
119	break;
120	case SWEEP_TYPE_INT:
121	snprintf (s, n, "%d", p.i);
122	break;
123	case SWEEP_TYPE_FLOAT:
124	snprintf (s, n, "%f", p.f);
125	break;
126	case SWEEP_TYPE_STRING:
127	snprintf (s, n, "%s", _(p.s));
128	break;
129	default:
130	break;
131	}
132	}
133
134	static void
135	print_param (sw_param_type type, sw_param p)
136	{
137	gchar buf[64];
138
139	snprint_param (buf, sizeof (buf), type, p);
140	printf ("%s", buf);
141	}
142
143	void
144	print_param_set (sw_procedure * proc, sw_param_set pset)
145	{
146	int i, j;
147	sw_param_spec * ps;
148	int valid_mask;
149
150	printf ("\"%s\" has %d params.\n\n", proc->name, proc->nr_params);
151
152	for (i=0; i < proc->nr_params; i++) {
153	ps = &proc->param_specs[i];
154	printf ("%d\t\"%s\" (\"%s\")\n", i, ps->name, ps->desc);
155	printf ("\tType: ");
156	print_type (ps->type);
157	printf ("\n");
158	if (ps->constraint_type == SW_PARAM_CONSTRAINED_NOT) {
159	printf ("\tUnconstrained.\n");
160	} else if (ps->constraint_type == SW_PARAM_CONSTRAINED_LIST) {
161	printf ("\tConstrained to ");
162	print_param (SWEEP_TYPE_INT, ps->constraint.list[0]);
163	printf (" list values.");
164	for (j=1; j <= ps->constraint.list[0].i; j++) {
165	printf ("\n\t");
166	print_param (ps->type, ps->constraint.list[j]);
167	}
168	printf ("\n");
169	} else if (ps->constraint_type == SW_PARAM_CONSTRAINED_RANGE) {
170	valid_mask = ps->constraint.range->valid_mask;
171
172	if (valid_mask & SW_RANGE_LOWER_BOUND_VALID) {
173	printf ("\tBounded below by ");
174	print_param (ps->type, ps->constraint.range->lower);
175	printf ("\n");
176	}
177	if (valid_mask & SW_RANGE_UPPER_BOUND_VALID) {
178	printf ("\tBounded above by ");
179	print_param (ps->type, ps->constraint.range->upper);
180	printf ("\n");
181	}
182	if (valid_mask & SW_RANGE_STEP_VALID) {
183	printf ("\tValues quantised by ");
184	print_param (ps->type, ps->constraint.range->step);
185	printf ("\n");
186	}
187	}
188	printf ("\tCURRENT VALUE ");
189	print_param (ps->type, pset[i]);
190	printf ("\n");
191	}
192	}
193
194	typedef enum {
195	SW_PS_TOGGLE_BUTTON,
196	SW_PS_KNOWN_PARAM,
197	SW_PS_ADJUSTMENT
198	} sw_ps_widget_t;
199
200	typedef struct _sw_ps_widget sw_ps_widget;
201	typedef struct _sw_ps_adjuster sw_ps_adjuster;
202
203	struct _sw_ps_widget {
204	sw_ps_widget_t type;
205	union {
206	GtkWidget * toggle_button;
207	sw_param * known_param;
208	GtkObject * adjustment;
209	} w;
210	};
211
212	struct _sw_ps_adjuster {
213	sw_procedure * proc;
214	sw_view * view;
215	sw_param_set pset;
216	GtkWidget * window;
217	GtkWidget * scrolled;
218	GtkWidget * table;
219	sw_ps_widget * widgets;
220	GList * plsk_list;
221	};
222
223	static sw_ps_adjuster *
224	ps_adjuster_new (sw_procedure * proc, sw_view * view, sw_param_set pset,
225	GtkWidget * window)
226	{
227	sw_ps_adjuster * ps;
228
229	ps = g_malloc (sizeof (*ps));
230
231	ps->proc = proc;
232	ps->view = view;
233	ps->pset = pset;
234	ps->window = window;
235
236	ps->scrolled = NULL;
237	ps->table = NULL;
238
239	ps->widgets = g_malloc (sizeof (sw_ps_widget) * proc->nr_params);
240	ps->plsk_list = NULL;
241
242	return ps;
243	}
244
245	static void
246	ps_adjuster_destroy (sw_ps_adjuster * ps)
247	{
248	}
249
250	static void
251	get_param_values (sw_procedure * proc, sw_param_set pset, sw_ps_widget * widgets)
252	{
253	gint i;
254	sw_param_spec * pspec;
255	gfloat value;
256
257	for (i=0; i < proc->nr_params; i++) {
258	pspec = &proc->param_specs[i];
259
260	switch (widgets[i].type) {
261	case SW_PS_TOGGLE_BUTTON:
262	/* Assume boolean */
263	pset[i].b = gtk_toggle_button_get_active
264	(GTK_TOGGLE_BUTTON(widgets[i].w.toggle_button));
265	break;
266	case SW_PS_KNOWN_PARAM:
267	param_copy (widgets[i].w.known_param, &pset[i]);
268	break;
269	case SW_PS_ADJUSTMENT:
270	value = GTK_ADJUSTMENT(widgets[i].w.adjustment)->value;
271	switch (pspec->type) {
272	case SWEEP_TYPE_BOOL:
273	pset[i].b = (value == 0.0);
274	break;
275	case SWEEP_TYPE_INT:
276	pset[i].i = (sw_int)(value);
277	break;
278	case SWEEP_TYPE_FLOAT:
279	pset[i].f = (sw_float)(value);
280	break;
281	default:
282
283	g_assert_not_reached ();
284
285	/* pset[i].i = 0; */
286	break;
287	}
288	break;
289	default:
290	break;
291	}
292	}
293	}
294
295	/*
296	* Callback for OK button of param_set_adjuster
297	*/
298	static void
299	param_set_apply_cb (GtkWidget * widget, gpointer data)
300	{
301	sw_ps_adjuster * ps = (sw_ps_adjuster *)data;
302
303	get_param_values (ps->proc, ps->pset, ps->widgets);
304
305	#ifdef DEBUG
306	print_param_set (ps->proc, ps->pset);
307	#endif
308
309	if (ps->proc->apply) {
310	ps->proc->apply (ps->view->sample,
311	ps->pset, ps->proc->custom_data);
312	}
313
314	gtk_widget_destroy (ps->window);
315
316	ps_adjuster_destroy (ps);
317	}
318
319	/*
320	* Callback for Cancel button of param_set_adjuster
321	*/
322	static void
323	param_set_cancel_cb (GtkWidget * widget, gpointer data)
324	{
325	sw_ps_adjuster * ps = (sw_ps_adjuster *)data;
326
327	gtk_widget_destroy (ps->window);
328
329	ps_adjuster_destroy (ps);
330	}
331
332	typedef struct _sw_pl_set_known sw_pl_set_known;
333
334	struct _sw_pl_set_known {
335	sw_param ** p1;
336	sw_param * p2;
337	};
338
339	/*
340	* Callback for setting known parameters from lists
341	*/
342	static void
343	param_list_set_known_cb (GtkWidget * widget, gpointer data)
344	{
345	sw_pl_set_known * plsk = (sw_pl_set_known *)data;
346
347	*(plsk->p1) = plsk->p2;
348	}
349
350	static GtkWidget *
351	create_param_set_table (sw_ps_adjuster * ps)
352	{
353	gint i, j;
354
355	sw_procedure * proc = ps->proc;
356	sw_param_set pset = ps->pset;
357
358	sw_param_spec * pspec;
359	sw_pl_set_known * plsk;
360	gint nr_options;
361	int valid=0;
362
363	gchar buf[64];
364
365	GtkWidget * table;
366	GtkWidget * hbox;
367	GtkWidget * label;
368	GtkWidget * optionmenu;
369	GtkWidget * menu;
370	GtkWidget * menuitem;
371	GtkWidget * checkbutton;
372	GtkWidget * num_widget; /* numeric input widget: hscale or spinbutton */
373
374	GtkObject * adj;
375	gfloat value, lower, upper, step_inc, page_inc, page_size;
376	gint digits = 1; /* nr. of decimal places to show on hscale */
377
378	table = gtk_table_new (proc->nr_params, 2, FALSE);
379
380	for (i=0; i < proc->nr_params; i++) {
381	pspec = &proc->param_specs[i];
382
383	if (pspec->type == SWEEP_TYPE_BOOL) {
384
385	checkbutton = gtk_check_button_new_with_label (_(pspec->name));
386	gtk_table_attach (GTK_TABLE (table), checkbutton, 0, 2, i, i+1,
387	GTK_FILL, GTK_FILL, 0, 0);
388
389	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton),
390	pset[i].b);
391
392	gtk_widget_show (checkbutton);
393
394	ps->widgets[i].type = SW_PS_TOGGLE_BUTTON;
395	ps->widgets[i].w.toggle_button = checkbutton;
396
397	/* YYY: yes, the naming seems inconsistent. GtkToggleButton is
398	* the parent class of GtkCheckButton
399	*/
400
401	} else {
402
403	hbox = gtk_hbox_new (FALSE, 0);
404	gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, i, i+1,
405	GTK_FILL\|GTK_SHRINK, GTK_SHRINK, 4, 4);
406	gtk_widget_show (hbox);
407
408	label = gtk_label_new (_(pspec->name));
409	gtk_box_pack_end (GTK_BOX(hbox), label, FALSE, FALSE, 4);
410	gtk_widget_show (label);
411
412	if (pspec->constraint_type == SW_PARAM_CONSTRAINED_LIST) {
413
414	optionmenu = gtk_option_menu_new ();
415	gtk_table_attach (GTK_TABLE (table), optionmenu, 1, 2, i, i+1,
416	GTK_FILL\|GTK_EXPAND, GTK_SHRINK, 0, 0);
417	gtk_widget_show (optionmenu);
418
419	menu = gtk_menu_new ();
420
421	ps->widgets[i].w.known_param = &pset[i];
422
423	nr_options = pspec->constraint.list[0].i;
424	plsk = g_malloc (sizeof (sw_pl_set_known) * nr_options);
425
426	ps->plsk_list = g_list_append (ps->plsk_list, plsk);
427
428	for (j=0; j < nr_options; j++) {
429	plsk[j].p1 = &ps->widgets[i].w.known_param;
430	plsk[j].p2 = &pspec->constraint.list[j+1];
431
432	snprint_param (buf, sizeof (buf), pspec->type,
433	pspec->constraint.list[j+1]);
434
435	menuitem = gtk_menu_item_new_with_label (buf);
436	gtk_menu_append (GTK_MENU(menu), menuitem);
437	gtk_widget_show (menuitem);
438
439	g_signal_connect (G_OBJECT(menuitem), "activate",
440	G_CALLBACK(param_list_set_known_cb), &plsk[j]);
441
442	if (!param_cmp (pspec->type, pspec->constraint.list[j+1], pset[i])) {
443	gtk_option_menu_set_history (GTK_OPTION_MENU(optionmenu), j);
444	ps->widgets[i].w.known_param = &pspec->constraint.list[j+1];
445	}
446	}
447
448	gtk_option_menu_set_menu (GTK_OPTION_MENU(optionmenu), menu);
449
450	ps->widgets[i].type = SW_PS_KNOWN_PARAM;
451
452
453	#define ADJUSTER_NUMERIC(T, DIGITS) \
454	\
455	value = (gfloat) pset[i].T; \
456	\
457	if (pspec->constraint_type == SW_PARAM_CONSTRAINED_NOT) { \
458	valid = 0; \
459	} else if (pspec->constraint_type == SW_PARAM_CONSTRAINED_RANGE) { \
460	valid = pspec->constraint.range->valid_mask; \
461	} \
462	\
463	if (valid & SW_RANGE_LOWER_BOUND_VALID) { \
464	lower = (gfloat) pspec->constraint.range->lower.T; \
465	} else { \
466	lower = G_MINFLOAT; \
467	} \
468	\
469	if (valid & SW_RANGE_UPPER_BOUND_VALID) { \
470	upper = (gfloat) pspec->constraint.range->upper.T; \
471	} else { \
472	upper = G_MAXFLOAT; \
473	} \
474	\
475	if (valid & SW_RANGE_STEP_VALID) { \
476	step_inc = (gfloat) pspec->constraint.range->step.T; \
477	} else if (lower != G_MINFLOAT && upper != G_MAXFLOAT) { \
478	step_inc = (upper - lower) / 100.0; \
479	} else { \
480	step_inc = (gfloat) 0.01; \
481	} \
482	page_inc = step_inc; \
483	page_size = step_inc; \
484	if (step_inc < 1.0) \
485	digits = - (gint)ceil(log10((double)step_inc)); \
486	else \
487	digits = 1; \
488	\
489	adj = gtk_adjustment_new (value, lower, upper, step_inc, \
490	page_inc, page_size); \
491	\
492	if ( (valid & SW_RANGE_LOWER_BOUND_VALID) && \
493	(valid & SW_RANGE_UPPER_BOUND_VALID)) { \
494	GTK_ADJUSTMENT(adj)->upper += step_inc; \
495	num_widget = gtk_hscale_new (GTK_ADJUSTMENT(adj)); \
496	gtk_scale_set_digits (GTK_SCALE(num_widget), digits); \
497	gtk_widget_set_size_request (num_widget, 75, -1); \
498	gtk_table_attach (GTK_TABLE (table), num_widget, 1, 2, i, i+1, \
499	GTK_FILL\|GTK_EXPAND, GTK_SHRINK, 0, 0); \
500	} else { \
501	num_widget = gtk_spin_button_new (GTK_ADJUSTMENT(adj), \
502	10.0, /* climb_rate */ \
503	(DIGITS)/* digits */ \
504	); \
505	gtk_spin_button_set_numeric (GTK_SPIN_BUTTON(num_widget), TRUE); \
506	gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON(num_widget), \
507	TRUE); \
508	gtk_widget_set_size_request (num_widget, 75, -1); \
509	gtk_table_attach (GTK_TABLE (table), num_widget, 1, 2, i, i+1, \
510	GTK_FILL\|GTK_EXPAND, GTK_SHRINK, 0, 0); \
511	} \
512	\
513	gtk_widget_show (num_widget); \
514	ps->widgets[i].type = SW_PS_ADJUSTMENT; \
515	ps->widgets[i].w.adjustment = adj;
516
517	} else if (pspec->type == SWEEP_TYPE_INT) {
518	ADJUSTER_NUMERIC(i, 0);
519	} else if (pspec->type == SWEEP_TYPE_FLOAT) {
520	ADJUSTER_NUMERIC(f, 3);
521	}
522	}
523	}
524
525	return table;
526	}
527
528	/*
529	* Callback for Suggest button of param_set_adjuster
530	*/
531	static void
532	param_set_suggest_cb (GtkWidget * widget, gpointer data)
533	{
534	sw_ps_adjuster * ps = (sw_ps_adjuster *)data;
535
536	GtkWidget * table;
537
538	if (ps->proc->suggest) {
539	ps->proc->suggest (ps->view->sample,
540	ps->pset, ps->proc->custom_data);
541	}
542
543	gtk_widget_destroy (ps->table);
544
545	table = create_param_set_table (ps);
546	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (ps->scrolled),
547	table);
548	gtk_widget_show (table);
549
550	ps->table = table;
551	}
552
553	gint
554	create_param_set_adjuster (sw_procedure * proc, sw_view * view,
555	sw_param_set pset)
556	{
557	sw_ps_adjuster * ps;
558	GtkWidget * window;
559	GtkWidget * main_vbox;
560	GtkWidget * pixmap;
561	GtkWidget * label;
562	GtkWidget * scrolled;
563	GtkWidget * ebox;
564	GtkWidget * hbox;
565	GtkWidget * vbox;
566	GtkWidget * table;
567	GtkWidget * frame;
568	GtkWidget * button, * ok_button;
569
570	/* Place the meta info about the plugin in a text widget (white background)
571	* aligned to the left of the parameter settings by defining _USE_TEXT
572	*/
573	/#define _USE_TEXT/
574
575	#ifdef _USE_TEXT
576	GtkWidget * text;
577
578	gchar buf[1024];
579	gint n;
580
581	#endif /* _USE_TEXT */
582
583	window = gtk_dialog_new ();
584	gtk_window_set_title (GTK_WINDOW(window), _(proc->name));
585	/* gtk_container_border_width (GTK_CONTAINER (window), 8);*/
586
587	ps = ps_adjuster_new (proc, view, pset, window);
588
589	g_signal_connect (G_OBJECT(window), "destroy",
590	G_CALLBACK(param_set_cancel_cb), ps);
591
592	#ifdef _USE_TEXT
593	hbox = gtk_hbox_new (FALSE, 0);
594	gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), hbox, TRUE, TRUE, 0);
595	gtk_widget_show (hbox);
596
597	text = gtk_text_new (NULL, NULL);
598	gtk_text_set_editable (GTK_TEXT (text), FALSE);
599	gtk_text_set_word_wrap (GTK_TEXT (text), FALSE);
600	gtk_widget_set_size_request (text, 320, -1);
601	gtk_box_pack_start (GTK_BOX (hbox), text, FALSE, FALSE, 0);
602	gtk_widget_show (text);
603
604	main_vbox = gtk_vbox_new (FALSE, 0);
605	gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
606	gtk_widget_show (main_vbox);
607
608	vbox = main_vbox;
609
610	gtk_text_freeze (GTK_TEXT (text));
611
612	#else
613
614	main_vbox = GTK_DIALOG(window)->vbox;
615
616	ebox = gtk_event_box_new ();
617	gtk_box_pack_start (GTK_BOX(main_vbox), ebox, FALSE, FALSE, 0);
618	gtk_widget_set_style (ebox, style_bw);
619	gtk_widget_show (ebox);
620
621	hbox = gtk_hbox_new (FALSE, 0);
622	gtk_container_add (GTK_CONTAINER(ebox), hbox);
623	gtk_container_set_border_width (GTK_CONTAINER(hbox), 4);
624	gtk_widget_show (hbox);
625
626	pixmap = create_widget_from_xpm (window, ladlogo_xpm);
627	gtk_box_pack_start (GTK_BOX(hbox), pixmap, FALSE, FALSE, 0);
628	gtk_widget_show (pixmap);
629
630	vbox = gtk_vbox_new (FALSE, 0);
631	gtk_box_pack_start (GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
632	gtk_widget_show (vbox);
633
634
635	#endif
636
637	if (proc->name != NULL) {
638
639	#ifdef _USE_TEXT
640	/*
641	* font =
642	* gdk_font_load("-Adobe-Helvetica-Medium-R-Normal---140------*");
643	*
644	* n = snprintf (buf, sizeof (buf), "%s\n\n", _(proc->name));
645	* gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, buf, n);
646	*/
647	#else
648
649	/* pangoise?
650	*
651	* style = gtk_style_new ();
652	* gdk_font_unref (style->font);
653	* style->font =
654	* gdk_font_load("-adobe-helvetica-medium-r-normal---180------");
655	* gtk_widget_push_style (style);
656	*/
657	label = gtk_label_new (_(proc->name));
658	gtk_misc_set_padding (GTK_MISC (label), 10, 10);
659	gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
660	gtk_widget_show (label);
661
662	/* gtk_widget_pop_style ();*/
663
664	#endif
665	}
666
667	#ifdef _USE_TEXT
668	n = 0;
669
670	if (proc->description != NULL) {
671	n = snprintf (buf, sizeof (buf), "%s\n\n", _(proc->description));
672	}
673
674	if (n < sizeof (buf) && proc->author != NULL) {
675	n += snprintf (buf+n, sizeof (buf)-n, "by %s", proc->author);
676	}
677
678	if (n < sizeof (buf) && proc->copyright != NULL) {
679	n += snprintf (buf+n, sizeof (buf)-n, ", %s.\n", proc->copyright);
680	}
681
682	if (n < sizeof (buf) && proc->url != NULL) {
683	n += snprintf (buf+n, sizeof (buf)-n, "\nFor more information see\n%s\n",
684	proc->url);
685	}
686
687	if (n > 0) {
688	gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, buf, n);
689	}
690
691	gtk_text_thaw (GTK_TEXT (text));
692
693	#else
694	if (proc->description != NULL) {
695	label = gtk_label_new (_(proc->description));
696	gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
697	gtk_widget_show (label);
698	}
699
700	if (proc->author != NULL) {
701	label = gtk_label_new (proc->author);
702	gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
703	gtk_widget_show (label);
704	}
705
706	if (proc->copyright != NULL) {
707	label = gtk_label_new (proc->copyright);
708	gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
709	gtk_widget_show (label);
710	}
711
712	if (proc->url != NULL) {
713	label = gtk_label_new (proc->url);
714	gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
715	gtk_widget_show (label);
716	}
717	#endif
718
719	hbox = gtk_hbox_new (FALSE, 0);
720	gtk_box_pack_start (GTK_BOX(main_vbox), hbox, TRUE, TRUE, 8);
721	gtk_widget_show (hbox);
722
723	frame = gtk_frame_new (_("Parameters"));
724	gtk_box_pack_start (GTK_BOX(hbox), frame, TRUE, TRUE, 8);
725	gtk_widget_show (frame);
726
727	vbox = gtk_vbox_new (FALSE, 4);
728	gtk_container_add (GTK_CONTAINER (frame), vbox);
729	gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
730	gtk_widget_show (vbox);
731
732	button = gtk_button_new_with_label (_("Defaults"));
733	gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 8);
734	gtk_widget_show (button);
735	g_signal_connect (G_OBJECT(button), "clicked",
736	G_CALLBACK (param_set_suggest_cb), ps);
737
738	scrolled = gtk_scrolled_window_new (NULL, NULL);
739	gtk_widget_set_size_request (scrolled, -1, 240);
740	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
741	GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
742	gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 8);
743	gtk_widget_show (scrolled);
744
745	table = create_param_set_table (ps);
746	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
747	table);
748	gtk_widget_show (table);
749
750	ps->scrolled = scrolled;
751	ps->table = table;
752
753	ok_button = gtk_button_new_with_label (_("OK"));
754	GTK_WIDGET_SET_FLAGS (GTK_WIDGET (ok_button), GTK_CAN_DEFAULT);
755	gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->action_area), ok_button,
756	TRUE, TRUE, 0);
757	gtk_widget_show (ok_button);
758	g_signal_connect (G_OBJECT(ok_button), "clicked",
759	G_CALLBACK (param_set_apply_cb), ps);
760
761
762	button = gtk_button_new_with_label (_("Cancel"));
763	GTK_WIDGET_SET_FLAGS (GTK_WIDGET (button), GTK_CAN_DEFAULT);
764	gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->action_area), button,
765	TRUE, TRUE, 0);
766	gtk_widget_show (button);
767	g_signal_connect (G_OBJECT(button), "clicked",
768	G_CALLBACK (param_set_cancel_cb), ps);
769
770	gtk_widget_grab_default (ok_button);
771
772	gtk_widget_show (window);
773
774	return 1;
775	}

Note: See TracBrowser for help on using the browser.

root/sweep/trunk/src/param.c

Download in other formats: