1 /*****
2 * Xnee's Not an Event Emulator
3 *
4 * Xnee enables recording and replaying of X protocol data
5 *
6 * Copyright (C) 2003, 2004, 2005
7 * 2010, 2011 Henrik Sandklef and Jon-Erling Dahl
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 3
12 * of the License, or any later version.
13 *
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Boston,
23 * MA 02110-1301, USA.
24 ****/
25
26 #include <gtk/gtk.h>
27
28 #include <pthread.h>
29 #include <support.h>
30 #include <string.h>
31
32
33 #include "gnee_xnee.h"
34 #include "interface.h"
35 #include <libxnee/print.h>
36 #include <libxnee/xnee_record.h>
37 #include <libxnee/xnee_replay.h>
38 #include <libxnee/xnee_setget.h>
39 #include <libxnee/datastrings.h>
40 #include <libxnee/xnee_range.h>
41 #include <libxnee/xnee_threshold.h>
42 #include <libxnee/xnee_setget.h>
43 #include <libxnee/xnee_error.h>
44 #include <libxnee/xnee_session.h>
45 #include <libxnee/xnee_alloc.h>
46
47 #include <callbacks.h>
48
49
50 /* static gnee_xnee gx ; */
51 /* static pthread_t action_thread; */
52
53
54 extern xnee_data *ext_xd;
55 extern gnee_xnee *ext_gx;
56 extern GtkWidget *ext_gnee_window;
57 static GtkWidget *err_win=NULL;
58
59
60
61
62
63 void
gx_init_gx(gnee_xnee * gx)64 gx_init_gx(gnee_xnee *gx)
65 {
66 GNEE_DEBUG(("gx_init_gx\n"));
67 gx->use_rec_display = 0 ;
68 gx->use_rep_display = 0 ;
69
70 gx->use_speed = 0 ;
71 gx->speed = 100 ;
72 }
73
74 static int
gx_is_using_rec_display(gnee_xnee * gx)75 gx_is_using_rec_display(gnee_xnee *gx) { return (gx->use_rec_display!=0); }
76
77 static int
gx_is_using_rep_display(gnee_xnee * gx)78 gx_is_using_rep_display(gnee_xnee *gx) { return (gx->use_rep_display!=0); }
79
80 /*static int
81 gx_is_using_speed(gnee_xnee *gx) { return (gx->use_speed!=0);}
82 */
83
84
85
86
87 int
gnee_set_cb(char * cb_name,int on_or_off)88 gnee_set_cb(char * cb_name, int on_or_off)
89 {
90 GtkToggleButton *togglebutton;
91
92 togglebutton = (GtkToggleButton*)lookup_widget (ext_gnee_window,
93 cb_name);
94 if (togglebutton!=NULL)
95 {
96 gtk_toggle_button_set_active(togglebutton, on_or_off);
97 }
98 return GNEE_OK;
99 }
100
101 void
gnee_set_sb(char * sb_name,int val)102 gnee_set_sb(char *sb_name, int val)
103 {
104 GtkSpinButton *spinbutton;
105 GNEE_DEBUG(("gnee_set_sb\n"));
106 spinbutton = (GtkSpinButton *)
107 lookup_widget (ext_gnee_window, sb_name);
108
109 if (spinbutton!=NULL)
110 {
111 gtk_spin_button_set_value(spinbutton, val);
112 }
113 }
114
115
116
117
118
119 static int
gnee_set_interval()120 gnee_set_interval()
121 {
122 GtkSpinButton *spin=NULL;
123 GtkToggleButton *togglebutton;
124
125 GNEE_DEBUG(("gnee_set_interval\n"));
126 spin = (GtkSpinButton*)lookup_widget (ext_gnee_window,
127 "wait_spinbutton");
128 togglebutton = (GtkToggleButton*)lookup_widget (ext_gnee_window,
129 "wait_checkbox");
130
131 if (spin!=NULL)
132 {
133 gtk_spin_button_set_value(spin,
134 xnee_get_interval(ext_xd));
135
136 }
137 if (togglebutton!=NULL)
138 {
139 gtk_toggle_button_set_active(togglebutton, 1);
140 }
141
142
143
144 return GNEE_OK;
145 }
146
147 int
gnee_set_verbosity(int on_or_off)148 gnee_set_verbosity(int on_or_off)
149 {
150 GNEE_DEBUG(("gnee_set_verbosity\n"));
151 return gnee_set_cb ("verbose_logging_checkbox", on_or_off);
152 }
153
154 int
gnee_set_no_feedback()155 gnee_set_no_feedback()
156 {
157 GNEE_DEBUG(("gnee_set_no\n"));
158 return gnee_set_cb ("no_fb_b", 1);
159 }
160
161 int
gnee_set_xosd_feedback()162 gnee_set_xosd_feedback()
163 {
164 GNEE_DEBUG(("gnee_set_xosd\n"));
165 return gnee_set_cb ("xosd_fb_b", 1);
166 }
167
168 /*
169 static int
170 gnee_set_stderr_feedback()
171 {
172 GNEE_DEBUG(("gnee_set_stderr\n"));
173 gnee_set_cb ("stderr_fb_b", 1);
174 return XNEE_OK;
175 }
176 */
177
178 static int
gnee_set_various_display(int use_recording_display)179 gnee_set_various_display(int use_recording_display)
180 {
181 GtkWidget *disp_text;
182 char *disp_to;
183
184 GNEE_DEBUG(("gnee_set_various\n"));
185 if (use_recording_display)
186 {
187 disp_text = (GtkWidget*)
188 lookup_widget (ext_gnee_window, "rec_disp_text");
189 }
190 else
191 {
192 disp_text = (GtkWidget*)
193 lookup_widget (ext_gnee_window, "rep_disp_text");
194 }
195
196 if (disp_text==NULL)
197 {
198 ;
199 }
200 else
201 {
202 disp_to = xnee_get_display_name(ext_xd);
203
204 gtk_entry_set_text((GtkEntry*)disp_text,
205 disp_to);
206 }
207 return GNEE_OK;
208 }
209
210
211 int
gx_set_record_display(xnee_data * xd,gnee_xnee * gx)212 gx_set_record_display(xnee_data *xd, gnee_xnee *gx)
213 {
214 GtkWidget *rec_disp_text;
215
216 GNEE_DEBUG(("gx_set_record\n"));
217
218 if (gx_is_using_rec_display(gx))
219 {
220 rec_disp_text = (GtkWidget*)
221 lookup_widget (ext_gnee_window, "rec_disp_text");
222
223 if (rec_disp_text==NULL)
224 {
225 xnee_set_display_name(ext_xd, "");
226 }
227 else
228 {
229 xnee_verbose((xd, "set record display to %s\n",
230 gtk_entry_get_text((GtkEntry*)rec_disp_text)));
231 xnee_set_display_name(ext_xd,
232 (char*)
233 gtk_entry_get_text((GtkEntry*)rec_disp_text));
234 }
235 }
236 else
237 {
238 xnee_set_display_name(ext_xd, "");
239 }
240 return GNEE_OK;
241 }
242
243 int
gx_set_replay_display(xnee_data * xd,gnee_xnee * gx)244 gx_set_replay_display(xnee_data *xd, gnee_xnee *gx)
245 {
246 GtkWidget *rep_disp_text;
247
248 GNEE_DEBUG(("gx_set_replay\n"));
249
250 if (gx_is_using_rep_display(gx))
251 {
252 rep_disp_text = (GtkWidget*)
253 lookup_widget (ext_gnee_window, "rep_disp_text");
254
255 if (rep_disp_text==NULL)
256 {
257 xnee_set_display_name(ext_xd, "");
258 }
259 else
260 {
261 xnee_verbose((xd, "set replay display to %s\n",
262 gtk_entry_get_text((GtkEntry*)rep_disp_text)));
263 xnee_set_display_name(ext_xd,
264 (char*)
265 gtk_entry_get_text((GtkEntry*)rep_disp_text));
266 }
267 }
268 else
269 {
270 xnee_set_display_name(ext_xd, "");
271 }
272 return GNEE_OK;
273 }
274
275
276 int
gx_set_variable_data(xnee_data * xd,gnee_xnee * gx)277 gx_set_variable_data(xnee_data *xd, gnee_xnee *gx)
278 {
279 GNEE_DEBUG(("gx_set_variable\n"));
280
281 /*
282 * Set display (record or replay)
283 */
284 if (xnee_is_recorder(xd))
285 {
286 gx_set_record_display(xd, gx);
287 }
288 else if (xnee_is_replayer(xd))
289 {
290 gx_set_replay_display(xd, gx);
291 }
292
293 GNEE_DEBUG(( "Speed settings : %d (%d) using=%d\n",
294 xnee_get_replay_speed(xd),
295 ext_gx->speed,
296 ext_gx->use_speed));
297
298
299 return GNEE_OK;
300 }
301
302
303
304
305 void
gnee_set_events_max(int val)306 gnee_set_events_max(int val)
307 {
308 GtkSpinButton *spinbutton;
309 GNEE_DEBUG(("gnee_set_events\n"));
310
311 spinbutton = (GtkSpinButton *)
312 lookup_widget (ext_gnee_window, "spinbutton11");
313 gtk_spin_button_set_value(spinbutton, val);
314 }
315
316 void
gnee_set_max_thresh(int val)317 gnee_set_max_thresh(int val)
318 {
319 GNEE_DEBUG(("gnee_set_max\n"));
320 gnee_set_sb("max_thresh_sb", val);
321 }
322
323 void
gnee_set_min_thresh(int val)324 gnee_set_min_thresh(int val)
325 {
326 GNEE_DEBUG(("thresh(int val\n"));
327 gnee_set_sb("min_thresh_sb", val);
328 }
329
330 void
gnee_set_tot_thresh(int val)331 gnee_set_tot_thresh(int val)
332 {
333 GNEE_DEBUG(("gnee_set_tot\n"));
334 gnee_set_sb("tot_thresh_sb", val);
335 }
336
337 void
gnee_set_data_max(int val)338 gnee_set_data_max(int val)
339 {
340 GtkSpinButton *spinbutton;
341 GNEE_DEBUG(("gnee_set_data\n"));
342
343 spinbutton = (GtkSpinButton *)
344 lookup_widget (ext_gnee_window, "spinbutton12");
345 gtk_spin_button_set_value(spinbutton, val);
346 }
347
348
349 void
gnee_set_time_max(int val)350 gnee_set_time_max(int val)
351 {
352 GtkSpinButton *spinbutton;
353
354 GNEE_DEBUG(("gnee_set_time\n"));
355 spinbutton = (GtkSpinButton *)
356 lookup_widget (ext_gnee_window, "spinbutton13");
357 gtk_spin_button_set_value(spinbutton, val);
358 }
359
360
361
362
363
364 void
gx_save(void)365 gx_save(void)
366 {
367 GNEE_DEBUG(("gx_save(void\n"));
368 if (ext_xd != NULL)
369 {
370 FILE *file;
371 char *fname = xnee_get_rc_name(ext_xd);
372
373 if (fname == NULL)
374 {
375 printf ("Implement me... no file to save\n");
376 }
377 else
378 {
379 file = fopen (fname, "w");
380 xnee_write_settings_to_file (ext_xd, file) ;
381 fclose (file);
382 }
383 }
384 }
385
386
387
388
389
390
391
392 void
gnee_set_ranges(int type)393 gnee_set_ranges(int type)
394 {
395 int i = 0 ;
396 int len = 0 ;
397 int *data = NULL ;
398 char *name = NULL ;
399
400 GNEE_DEBUG(("gnee_set_ranges\n"));
401
402 len = xnee_get_nr_of_data(type);
403 data = xnee_get_data (type);
404
405 GNEE_DEBUG(("Setting ranges from project file \n"));
406
407 for (i=0;i<len;i++)
408 {
409 name = (char*) xnee_int2data(type, data[i]);
410
411 if ( (type==XNEE_DEVICE_EVENT)
412 || (type==XNEE_DELIVERED_EVENT)
413 || (type==XNEE_EVENT))
414 {
415 GNEE_DEBUG(("Adding from proj file: \t%.3d (%s)\n",
416 data[i], name ));
417 gx_add_event(ext_gnee_window, name);
418 }
419 else if ( type==XNEE_ERROR)
420 {
421 GNEE_DEBUG(("\t%.3d (%s)\n",
422 data[i], name ));
423 gx_add_error(ext_gnee_window, name);
424 }
425 else if ( type==XNEE_REPLY)
426 {
427 GNEE_DEBUG(("\t%.3d (%s)\n",
428 data[i], name ));
429 gx_add_reply(ext_gnee_window, name);
430 }
431 else if ( type==XNEE_REQUEST)
432 {
433 GNEE_DEBUG(("\t%.3d (%s)\n",
434 data[i], name ));
435 gx_add_request (ext_gnee_window, name);
436 }
437 else
438 ;
439 }
440 }
441
442
443
444
445 void
gx_set_xd_settings()446 gx_set_xd_settings()
447 {
448 int val;
449 int i ;
450
451 GNEE_DEBUG(("gx_set_xd\n"));
452
453 if (ext_gnee_window == NULL)
454 {
455 fprintf (stderr, "Could not find a gnee_window in\n");
456 }
457
458 val = xnee_get_events_max(ext_xd);
459 gnee_set_events_max(val);
460
461 val = xnee_get_data_max(ext_xd);
462 gnee_set_data_max(val);
463
464 val = xnee_get_time_max(ext_xd);
465 gnee_set_time_max(val);
466
467
468 val = xnee_get_max_threshold(ext_xd);
469 gnee_set_max_thresh(val);
470
471 val = xnee_get_min_threshold(ext_xd);
472 gnee_set_min_thresh(val);
473
474 val = xnee_get_tot_threshold(ext_xd);
475 gnee_set_tot_thresh(val);
476
477 for (i=1;i<XNEE_NR_OF_TYPES;i++)
478 {
479 gnee_set_ranges(i);
480 }
481
482 gnee_set_record_display();
483 gnee_set_replay_display();
484
485 if (xnee_is_verbose(ext_xd))
486 {
487 gnee_set_verbose();
488 }
489 else
490 {
491 gnee_unset_verbose();
492 }
493
494 gnee_set_interval();
495
496 if (xnee_is_sync(ext_xd))
497 {
498 gnee_set_sync();
499 }
500 else
501 {
502 gnee_unset_sync();
503 }
504
505 if (xnee_is_force_replay(ext_xd))
506 {
507 gnee_set_force();
508 }
509 else
510 {
511 gnee_unset_force();
512 }
513 }
514
515
516 /*
517 static int
518 gx_init_xnee (xnee_data *xd)
519 {
520
521 static int need_init = 1;
522
523 GNEE_DEBUG(("gx_init_xnee\n"));
524
525 if (xd==NULL)
526 {
527 return 1;
528 }
529
530 if (need_init!=1)
531 {
532 return 0;
533 }
534
535
536 (void) signal (SIGINT, signal_handler);
537
538 xd = xnee_new_xnee_data();
539 need_init=0;
540 return 0;
541 }
542 */
543
544 void
gnee_reset_gnee()545 gnee_reset_gnee()
546 {
547 GNEE_DEBUG(("gnee_reset_gnee\n"));
548 }
549
550
551
552
553 int
gnee_get_grab(xnee_data * xd)554 gnee_get_grab(xnee_data* xd)
555 {
556 on_stop_k_combo_changed(NULL,
557 ext_gnee_window);
558 on_pause_k_combo_changed(NULL,
559 ext_gnee_window);
560 on_resume_k_combo_changed(NULL,
561 ext_gnee_window);
562 on_mark_k_combo_changed(NULL,
563 ext_gnee_window);
564 on_exec_k_combo_changed(NULL,
565 ext_gnee_window);
566
567 return XNEE_OK;
568 }
569
570 int
gx_start_recording(xnee_data * xd)571 gx_start_recording(xnee_data* xd)
572 {
573 int ret;
574
575 GNEE_DEBUG(("gx_start_recording\n"));
576
577 GNEE_DEBUG(("Setting grab state\n"));
578 gnee_get_grab(xd);
579
580 GNEE_DEBUG(("Starting recorder\n"));
581 xnee_set_recorder (xd);
582
583 GNEE_DEBUG(("setting variable data\n"));
584 ret = gx_set_variable_data(xd, ext_gx);
585 GNEE_IF_ERROR_RETURN(ret,ext_gnee_window);
586
587 GNEE_DEBUG(("start recording\n"));
588
589 ret = xnee_start(xd);
590 GNEE_IF_ERROR_RETURN(ret,ext_gnee_window);
591
592 GNEE_DEBUG((" recorder stopped\n"));
593
594 fflush(stdout);
595 return 0;
596 }
597
598 int
gx_stop_recording(xnee_data * xd)599 gx_stop_recording(xnee_data* xd)
600 {
601 xnee_verbose((xd, "stop recording\n"));
602 return 0;
603 }
604
605 int
gx_start_replaying(xnee_data * xd)606 gx_start_replaying(xnee_data* xd)
607 {
608 int ret ;
609
610 GNEE_DEBUG(("gx_start_replaying\n"));
611
612 GNEE_DEBUG(("Starting replayer\n"));
613 xnee_set_replayer(xd);
614
615 GNEE_DEBUG(("setting variable data\n"));
616 ret = gx_set_variable_data(xd, ext_gx);
617 GNEE_IF_ERROR_RETURN(ret,ext_gnee_window);
618
619 GNEE_DEBUG(("start replaying\n"));
620
621 ret = xnee_start(xd);
622 GNEE_IF_ERROR_RETURN(ret,ext_gnee_window);
623
624 GNEE_DEBUG((" replayer stopped\n"));
625 return 0;
626 }
627
628 int
gx_stop_replaying(xnee_data * xd)629 gx_stop_replaying(xnee_data* xd)
630 {
631 GNEE_DEBUG(("gx_stop_replaying\n"));
632 xnee_verbose((xd, "stop replaying\n"));
633 return 0;
634 }
635
636 /*
637 static char *gx_modifiers[] = {
638 "None",
639 "Any",
640 "Control",
641 "Shift",
642 "Alt",
643 "Control+Shift",
644 "Control+Alt",
645 "Shift+Alt",
646 "Control+Shift+Alt",
647 NULL };
648 */
649 static char *gx_keys[] = {
650 "None",
651 "space",
652 "F1", "F2", "F3", "F4",
653 "F5", "F6", "F7", "F8",
654 "F9", "F10", "F11", "F12",
655 "a", "b", "c", "d", "e",
656 "f", "g", "h", "i", "j",
657 "k", "l", "m", "n", "o",
658 "p", "q", "r", "s", "t",
659 "u", "v", "x", "y", "z",
660 "0", "1", "2", "3", "4",
661 "5", "6", "7", "8", "9",
662 NULL };
663
664
665 static void
create_km_list(GtkWidget * k_combo)666 create_km_list(GtkWidget *k_combo)
667 {
668 int i = 0 ;
669 /* GList *m_items = NULL; */
670 GList *k_items = NULL;
671
672 GNEE_DEBUG(("create_km_list\n"));
673 /* GNEE_DEBUG(("Add modifiers\n")); */
674 i=0;
675 /* while (gx_modifiers[i]!=NULL) */
676 /* { */
677 /* GNEE_DEBUG(("Adding modifier: %s\n", gx_modifiers[i])); */
678 /* m_items = g_list_append (m_items, gx_modifiers[i]); */
679 /* i++; */
680 /* } */
681 /* GNEE_DEBUG(("Adding modifiers to popdown\n")); */
682 /* gtk_combo_set_popdown_strings (GTK_COMBO (m_combo), m_items); */
683
684
685
686 /* GNEE_DEBUG(("Add keys\n")); */
687 i=0;
688 while (gx_keys[i]!=NULL)
689 {
690 /* GNEE_DEBUG(("Adding key: %s\n", gx_keys[i])); */
691 k_items = g_list_append (k_items, gx_keys[i]);
692 i++;
693 }
694 gtk_combo_set_popdown_strings (GTK_COMBO (k_combo), k_items);
695 }
696
697
698 static void
create_km_lists_sub(char * key_c)699 create_km_lists_sub(char *key_c)
700 {
701 /* GtkWidget *m_entry; */
702 GtkWidget *k_entry;
703
704 GNEE_DEBUG(("create_km_lists\n"));
705 /* m_entry = (GtkWidget *) lookup_widget (ext_gnee_window, mod_c); */
706 k_entry = (GtkWidget *) lookup_widget (ext_gnee_window, key_c);
707 /* create_km_list(m_entry,k_entry); */
708 create_km_list(k_entry);
709 }
710
711 void
gx_create_km_lists()712 gx_create_km_lists()
713 {
714 GNEE_DEBUG(("gx_create_km\n"));
715 /****************************************************
716 * combo#
717 1 stop modifier
718 2 stop key
719 3 pause modifier
720 4 resume modifier
721 5 mark modifier
722 6 exec modifier
723 7 pause key
724 8 resume key
725 9 mark key
726 10 exec key
727 ******************************************************/
728 create_km_lists_sub ("combo2");
729 create_km_lists_sub ("combo7");
730 create_km_lists_sub ("combo8");
731 create_km_lists_sub ("combo9");
732 create_km_lists_sub ("combo10");
733 }
734
735
736
737 void
gx_undisplay_errror()738 gx_undisplay_errror()
739 {
740 GNEE_DEBUG(("gx_undisplay_errror\n"));
741 gtk_widget_hide(err_win);
742 }
743
744 void
gx_display_errror(int err_nr)745 gx_display_errror(int err_nr)
746 {
747 GtkLabel *my_text;
748 #define GNEE_BUF_SIZE 8
749 gchar buf[GNEE_BUF_SIZE];
750 const char *str_ptr = NULL;
751 int i ;
752
753 GNEE_DEBUG(("create_km_list\n"));
754 if (err_win == NULL)
755 {
756 err_win = create_dialog1();
757 }
758
759 /* number field */
760 my_text = (GtkLabel *)
761 lookup_widget (err_win, "err_nr_label");
762 snprintf (buf, GNEE_BUF_SIZE, "%d", err_nr);
763 gtk_label_set_text(my_text,buf);
764
765 /* description field */
766 my_text = (GtkLabel *)
767 lookup_widget (err_win, "descr_label");
768 if (my_text!=NULL)
769 {
770 str_ptr = xnee_get_err_description(err_nr);
771 if (str_ptr!=NULL)
772 {
773 gtk_label_set_text(my_text,str_ptr);
774 }
775 }
776
777 /* description field */
778 my_text = (GtkLabel *)
779 lookup_widget (err_win, "solu_label");
780 if (my_text!=NULL)
781 {
782 str_ptr = xnee_get_err_solution(err_nr);
783 if (str_ptr!=NULL)
784 {
785 gtk_label_set_text(my_text,str_ptr);
786 }
787 }
788
789 gtk_widget_show (err_win);
790
791
792 for (i=XNEE_OK;i<=XNEE_LAST_ERROR;i++)
793 {
794 printf ("%.2d\n\t%s\n\t%s\n",
795 i,
796 xnee_get_err_description(i),
797 xnee_get_err_solution(i)) ;
798 }
799
800 }
801
802
803
804
805 int
gx_set_use_speed(int val)806 gx_set_use_speed (int val)
807 {
808 GNEE_DEBUG(("gx_set_use_speed (%d)\n", val));
809
810 ext_gx->use_speed = val;
811
812 if (val==0)
813 {
814 gx_set_replay_speed(ext_xd, 100);
815 ;
816 }
817 else
818 {
819 GtkSpinButton *spinbutton;
820 int val ;
821
822 spinbutton = (GtkSpinButton *)
823 lookup_widget (ext_gnee_window, "speed_spin");
824 val = gtk_spin_button_get_value_as_int(spinbutton);
825 GNEE_DEBUG(("gx_set_replay_speed (%d\n", val));
826 gx_set_replay_speed(ext_xd, val);
827 }
828 return GNEE_OK;
829 }
830
831 int
gx_set_speed(int val)832 gx_set_speed (int val)
833 {
834 GNEE_DEBUG(("gx_set_speed to %d\n", val));
835 if ( ext_gx->use_speed != 0 )
836 {
837 gx_set_replay_speed(ext_xd, val);
838 ext_gx->speed = val ;
839 }
840 else
841 {
842 gx_set_replay_speed(ext_xd, 100);
843 }
844 return GNEE_OK;
845 }
846
847
848
849
850 void
gnee_set_rec_file(char * filename)851 gnee_set_rec_file(char *filename)
852 {
853 GtkEntry *file_text ;
854 GNEE_DEBUG(("gnee_set_rec\n"));
855
856 file_text = (GtkEntry*) lookup_widget(GTK_WIDGET(ext_gnee_window),
857 "rec_file_text");
858
859 gtk_entry_set_text (file_text,
860 filename);
861 xnee_set_out_name (ext_xd, filename);
862 }
863
864 void
gnee_set_rep_file(char * filename)865 gnee_set_rep_file(char *filename)
866 {
867 GtkEntry *file_text ;
868
869 GNEE_DEBUG(("gnee_set_rep\n"));
870 file_text = (GtkEntry*) lookup_widget(GTK_WIDGET(ext_gnee_window),
871 "rep_file_text");
872
873 gtk_entry_set_text (file_text,
874 filename);
875
876 xnee_set_data_name (ext_xd, filename);
877 }
878
879
880 void
gnee_close_down()881 gnee_close_down()
882 {
883 GNEE_DEBUG(("gnee_close_down\n"));
884 xnee_close_down(ext_xd);
885 exit(GNEE_OK);
886 }
887
888
889 char *
gx_get_default_filename()890 gx_get_default_filename()
891 {
892 char *tmp_dir = NULL;
893 char *user_name = NULL;
894
895 const char *default_tmp_dir = "/tmp/";
896 const char *default_user_name = "user";
897 const char *file_prefix = "gnee_";
898 const char *file_suffix = ".xns";
899
900 char *ret_str;
901 int size = 0 ;
902
903 GNEE_DEBUG(("gx_get_default\n"));
904
905 /* set the dir */
906 tmp_dir = getenv("TMPIR");
907 if (tmp_dir==NULL)
908 {
909 tmp_dir= (char *) default_tmp_dir;
910 }
911
912 /* set the user name */
913 user_name = getlogin();
914 if (user_name==NULL)
915 {
916 user_name = (char *) default_user_name;
917 }
918
919
920 #define GNEE_CHECK_CHAR_PTR(a) { if ( a==NULL) { fprintf(stderr, "Couldn't put together default file name\n") ; return NULL; } }
921 GNEE_CHECK_CHAR_PTR(tmp_dir);
922 GNEE_CHECK_CHAR_PTR(user_name);
923 GNEE_CHECK_CHAR_PTR(file_prefix);
924 GNEE_CHECK_CHAR_PTR(file_suffix);
925
926 size = strlen (tmp_dir) +
927 strlen (user_name) +
928 strlen (file_prefix) +
929 strlen (file_suffix) ;
930
931 if (size <= 0 )
932 {
933 fprintf (stderr, "Trying to allocate size %d\n", size);
934 }
935
936 ret_str = (char*) malloc (size*sizeof(char));
937 if (ret_str==NULL)
938 {
939 return NULL;
940 }
941
942 strncpy (ret_str, tmp_dir, size);
943 strncat (ret_str, file_prefix, size - strlen(ret_str));
944 strncat (ret_str, user_name, size - strlen(ret_str));
945 strncat (ret_str, file_suffix, size - strlen(ret_str));
946 return ret_str;
947 }
948
949