← Back to branch summary

~ubuntu-branches/ubuntu/breezy/tiemu/breezy

« back to all changes in this revision

Viewing changes to src/gui/gtk/link_cb.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien BLACHE
  • Date: 2005-06-02 16:50:15 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050602165015-59ab24414tl2wzol
Tags: 1.99+svn1460-1
* New snapshot.
* debian/control:
  + Updated build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/gtk/link_cb.c
1
 
#ifdef HAVE_CONFIG_H
2
 
#  include <config.h>
3
 
#endif
4
 
 
5
 
#include <gtk/gtk.h>
6
 
 
7
 
#include "link_cb.h"
8
 
#include "link_dbox.h"
9
 
#include "support.h"
10
 
 
11
 
#include "tilibs.h"
12
 
#include "platform.h"
13
 
#include "struct.h"
14
 
#include "ticalc.h"
15
 
#include "msg_cb.h"
16
 
#include "interface.h"
17
 
#include "main.h"
18
 
 
19
 
static gint  link_type;
20
 
static gchar device[MAXCHARS];
21
 
static guint io_addr;
22
 
static gint  port;
23
 
static gint  method;
24
 
 
25
 
static gint custom_toggled = 0;
26
 
static gint prev_link_type = 0;
27
 
 
28
 
gpointer wentry1 = NULL;
29
 
gpointer wentry2 = NULL;
30
 
 
31
 
 
32
 
static void s2v(void)
33
 
{
34
 
  port = (options.link_cable)->port;
35
 
  method = ticable_get_method();
36
 
  link_type = (options.link_cable)->link_type;
37
 
  io_addr = ticable_get_io_address();
38
 
  strcpy(device, ticable_get_io_device());
39
 
}
40
 
 
41
 
gint display_linktype_dbox()
42
 
{
43
 
  GtkWidget *dbox;
44
 
  gpointer user_data;
45
 
 
46
 
  dbox = create_linktype_dbox();
47
 
  s2v();
48
 
  
49
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton1");
50
 
  if(link_type == LINK_TGL)
51
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
52
 
 
53
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton2");
54
 
  if(link_type == LINK_PAR)
55
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
56
 
 
57
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton3");
58
 
  if(link_type == LINK_TIE)
59
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
60
 
 
61
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton4");
62
 
  if(link_type == LINK_TPU)
63
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
64
 
 
65
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton5");
66
 
  if(link_type == LINK_SER)
67
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
68
 
 
69
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton6");
70
 
  if(link_type == LINK_AVR)
71
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
72
 
 
73
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton7");
74
 
  if(link_type == LINK_VTI)
75
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
76
 
 
77
 
  user_data = gtk_object_get_data(GTK_OBJECT(dbox), "radiobutton8");
78
 
  if(link_type == LINK_UGL)
79
 
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data), TRUE);
80
 
 
81
 
  s2v();
82
 
 
83
 
  gtk_widget_show_all(dbox);
84
 
 
85
 
  return 0;
86
 
}
87
 
 
88
 
/************************************/
89
 
/* Called when the box is displayed */
90
 
/************************************/
91
 
 
92
 
 
93
 
void
94
 
on_linktype_dbox_show20                (GtkWidget       *widget,
95
 
                                        gpointer         user_data)
96
 
{
97
 
  //DISPLAY("show20\n");
98
 
  switch(link_type)
99
 
    {
100
 
    case LINK_PAR:
101
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
102
 
                         "Parallel port #1");
103
 
      if(port == PARALLEL_PORT_1)
104
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
105
 
      gtk_widget_show(GTK_WIDGET(GTK_BIN(user_data)->child));
106
 
      gtk_widget_show(user_data);
107
 
      break;
108
 
    case LINK_AVR:
109
 
    case LINK_TGL:
110
 
    case LINK_SER:
111
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
112
 
                         "Serial port #1");
113
 
      if(port == SERIAL_PORT_1)
114
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
115
 
      gtk_widget_show(user_data);
116
 
      break;
117
 
    case LINK_TIE:
118
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
119
 
                         "Virtual port #1 (emu)");
120
 
      if(port == VIRTUAL_PORT_1)
121
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
122
 
      gtk_widget_show(user_data);
123
 
      break;
124
 
    case LINK_VTI:
125
 
#ifdef __WIN32__
126
 
      gtk_widget_hide(user_data);
127
 
      break;
128
 
#endif
129
 
    case LINK_VTL:
130
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
131
 
                         "Virtual port #1 (emu)");
132
 
      if(port == VIRTUAL_PORT_1)
133
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
134
 
      gtk_widget_show(user_data);
135
 
      break;
136
 
    case LINK_TPU:
137
 
      gtk_widget_hide(user_data);
138
 
      /*
139
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
140
 
                         "'raw' mode");
141
 
      if(io_addr == TPU_RAW_MODE)
142
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
143
 
      gtk_widget_show(user_data);
144
 
      */
145
 
      break;
146
 
    case LINK_UGL:
147
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child),
148
 
                         "USB port #1");
149
 
      if(port == USB_PORT_1)
150
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
151
 
      gtk_widget_show(GTK_WIDGET(GTK_BIN(user_data)->child));
152
 
      gtk_widget_show(user_data);
153
 
      break;
154
 
    }
155
 
}
156
 
 
157
 
 
158
 
void
159
 
on_linktype_dbox_show21                (GtkWidget       *widget,
160
 
                                        gpointer         user_data)
161
 
{
162
 
  //DISPLAY("show21\n");
163
 
  switch(link_type)
164
 
    {
165
 
    case LINK_PAR:
166
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
167
 
                         "Parallel port #2");
168
 
      if(port == PARALLEL_PORT_2)
169
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
170
 
      gtk_widget_show(user_data);
171
 
      break;
172
 
    case LINK_AVR:
173
 
    case LINK_TGL:
174
 
    case LINK_SER:
175
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
176
 
                         "Serial port #2");
177
 
      if(port == SERIAL_PORT_2)
178
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
179
 
      gtk_widget_show(user_data);
180
 
      break;
181
 
    case LINK_TIE:
182
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
183
 
                         "Virtual port #2 (tilp)");
184
 
      if(port == VIRTUAL_PORT_2)
185
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
186
 
      gtk_widget_show(user_data);
187
 
      break;
188
 
    case LINK_VTI:
189
 
#ifdef __WIN32__
190
 
      gtk_widget_hide(user_data);
191
 
      break;
192
 
#endif
193
 
    case LINK_VTL:
194
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
195
 
                         "Virtual port #2 (tilp)");
196
 
      if(port == VIRTUAL_PORT_2)
197
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
198
 
      gtk_widget_show(user_data);
199
 
      break;
200
 
    case LINK_TPU:
201
 
      gtk_widget_hide(user_data);
202
 
      /*
203
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
204
 
                         "'cooked' mode");
205
 
      if(io_addr == TPU_COOKED_MODE)
206
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
207
 
      gtk_widget_show(user_data);
208
 
      */
209
 
      break;
210
 
    case LINK_UGL:
211
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child),
212
 
                         "USB port #2");
213
 
      if(port == USB_PORT_2)
214
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
215
 
      gtk_widget_show(GTK_WIDGET(GTK_BIN(user_data)->child));
216
 
      gtk_widget_show(user_data);
217
 
      break;
218
 
    }
219
 
}
220
 
 
221
 
 
222
 
void
223
 
on_linktype_dbox_show22                (GtkWidget       *widget,
224
 
                                        gpointer         user_data)
225
 
{
226
 
  //DISPLAY("show22\n");
227
 
  switch(link_type)
228
 
    {
229
 
    case LINK_PAR:
230
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
231
 
                         "Parallel port #3");
232
 
      if(port == PARALLEL_PORT_3)
233
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
234
 
      gtk_widget_show(user_data);
235
 
      break;
236
 
    case LINK_AVR:
237
 
    case LINK_TGL:
238
 
    case LINK_SER:
239
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
240
 
                         "Serial port #3");
241
 
      if(port == SERIAL_PORT_3)
242
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
243
 
      gtk_widget_show(user_data);
244
 
      break;
245
 
    case LINK_TIE:
246
 
      gtk_widget_hide(user_data);
247
 
      break;
248
 
    case LINK_VTI:
249
 
      gtk_widget_hide(user_data);
250
 
      break;
251
 
    case LINK_VTL:
252
 
      gtk_widget_hide(user_data);
253
 
      break;
254
 
    case LINK_TPU:
255
 
      gtk_widget_hide(user_data);
256
 
      break;
257
 
    case LINK_UGL:
258
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child),
259
 
                         "USB port #3");
260
 
      if(port == USB_PORT_3)
261
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
262
 
      gtk_widget_show(GTK_WIDGET(GTK_BIN(user_data)->child));
263
 
      gtk_widget_show(user_data);
264
 
      break;
265
 
    }
266
 
}
267
 
 
268
 
 
269
 
void
270
 
on_linktype_dbox_show23                (GtkWidget       *widget,
271
 
                                        gpointer         user_data)
272
 
{
273
 
  //DISPLAY("show23\n");
274
 
  switch(link_type)
275
 
    {
276
 
    case LINK_PAR:
277
 
      gtk_widget_hide(user_data);
278
 
      break;
279
 
    case LINK_AVR:
280
 
    case LINK_TGL:
281
 
    case LINK_SER:
282
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child), 
283
 
                         "Serial port #4");
284
 
      if(port == SERIAL_PORT_4)
285
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
286
 
      gtk_widget_show(user_data);
287
 
      break;
288
 
    case LINK_TIE:
289
 
      gtk_widget_hide(user_data);
290
 
      break;
291
 
    case LINK_VTI:
292
 
      gtk_widget_hide(user_data);
293
 
      break;
294
 
    case LINK_VTL:
295
 
      gtk_widget_hide(user_data);
296
 
      break;
297
 
    case LINK_TPU:
298
 
      gtk_widget_hide(user_data);
299
 
      break;
300
 
    case LINK_UGL:
301
 
      gtk_label_set_text(GTK_LABEL(GTK_BIN(user_data)->child),
302
 
                         "USB port #4");
303
 
      if(port == USB_PORT_4)
304
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
305
 
      gtk_widget_show(GTK_WIDGET(GTK_BIN(user_data)->child));
306
 
      gtk_widget_show(user_data);
307
 
      break;
308
 
    }
309
 
}
310
 
 
311
 
 
312
 
void
313
 
on_linktype_dbox_show24                (GtkWidget       *widget,
314
 
                                        gpointer         user_data)
315
 
{
316
 
  //DISPLAY("show24\n");
317
 
  switch(link_type)
318
 
    {
319
 
    case LINK_PAR:
320
 
      if(port == USER_PORT)
321
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
322
 
      gtk_widget_show(user_data);
323
 
      break;
324
 
    case LINK_AVR:
325
 
    case LINK_TGL:
326
 
    case LINK_SER:
327
 
      if(port == USER_PORT)
328
 
          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
329
 
      gtk_widget_show(user_data);
330
 
      break;
331
 
    case LINK_TIE:
332
 
      gtk_widget_hide(user_data);
333
 
      break;
334
 
    case LINK_VTI:
335
 
      gtk_widget_hide(user_data);
336
 
      break;
337
 
    case LINK_VTL:
338
 
      gtk_widget_hide(user_data);
339
 
      break;
340
 
    case LINK_TPU:
341
 
      gtk_widget_hide(user_data);
342
 
      break;
343
 
    case LINK_UGL:
344
 
      if(port == USER_PORT)
345
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (user_data), TRUE);
346
 
      gtk_widget_show(user_data);
347
 
      break;
348
 
    }
349
 
  //DISPLAY("port = %i\n", port);
350
 
}
351
 
 
352
 
 
353
 
void
354
 
on_linktype_dbox_show30                (GtkWidget       *widget,
355
 
                                        gpointer         user_data)
356
 
{
357
 
  gchar buffer[MAXCHARS];
358
 
 
359
 
  wentry1 = user_data;
360
 
  g_snprintf(buffer, MAXCHARS, "0x%03x", io_addr);
361
 
 
362
 
  gtk_entry_set_visibility(GTK_ENTRY(user_data), custom_toggled);
363
 
  gtk_entry_set_editable(GTK_ENTRY(user_data), custom_toggled ? TRUE : FALSE);
364
 
  gtk_entry_set_text(GTK_ENTRY(user_data), buffer);
365
 
}
366
 
 
367
 
 
368
 
void
369
 
on_linktype_dbox_show31                (GtkWidget       *widget,
370
 
                                        gpointer         user_data)
371
 
{
372
 
  gchar buffer[MAXCHARS];
373
 
 
374
 
  wentry2 = user_data;
375
 
  g_snprintf(buffer, MAXCHARS, "%s", device);
376
 
 
377
 
  gtk_entry_set_visibility(GTK_ENTRY(user_data), custom_toggled);
378
 
  gtk_entry_set_editable(GTK_ENTRY(user_data), custom_toggled ? TRUE : FALSE);
379
 
  gtk_entry_set_text(GTK_ENTRY(user_data), buffer);
380
 
}
381
 
 
382
 
 
383
 
/***********************************/
384
 
/* Called whenever a char is typed */
385
 
/***********************************/
386
 
 
387
 
void
388
 
linktype_entry1_changed                (GtkEditable     *editable,
389
 
                                        gpointer         user_data)
390
 
{
391
 
  gchar *s;
392
 
  gint result;
393
 
 
394
 
  s = gtk_editable_get_chars(GTK_EDITABLE(user_data), 0, -1);
395
 
  result = sscanf(s, "0x%03x", &io_addr);
396
 
  if(result < 1)
397
 
    io_addr = AUTO_ADDR;
398
 
}
399
 
 
400
 
 
401
 
void
402
 
linktype_entry2_changed                (GtkEditable     *editable,
403
 
                                        gpointer         user_data)
404
 
{
405
 
  gchar *s;
406
 
  gint result;
407
 
 
408
 
  s = gtk_editable_get_chars(GTK_EDITABLE(user_data), 0, -1);
409
 
  result = sscanf(s, "%s", device);
410
 
  if(result < 1)
411
 
    strcpy(device, AUTO_NAME);
412
 
}
413
 
 
414
 
 
415
 
/*******************/
416
 
/* Link cable type */
417
 
/*******************/
418
 
 
419
 
void
420
 
linktype_radiobutton1_toggled          (GtkToggleButton *togglebutton,
421
 
                                        gpointer         user_data)
422
 
{
423
 
  //DISPLAY("r1\n");
424
 
  link_type = LINK_TGL;
425
 
  //if(link_type != prev_link_type)
426
 
  //port = SERIAL_PORT_2;
427
 
  
428
 
  if(gtk_toggle_button_get_active(togglebutton))
429
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
430
 
}
431
 
 
432
 
void
433
 
linktype_radiobutton2_toggled          (GtkToggleButton *togglebutton,
434
 
                                        gpointer         user_data)
435
 
{
436
 
  //DISPLAY("r2\n");
437
 
  link_type = LINK_PAR;
438
 
  //if(link_type != prev_link_type)
439
 
  //port = PARALLEL_PORT_1;
440
 
 
441
 
  if(gtk_toggle_button_get_active(togglebutton))
442
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
443
 
}
444
 
 
445
 
void
446
 
linktype_radiobutton3_toggled          (GtkToggleButton *togglebutton,
447
 
                                        gpointer         user_data)
448
 
{
449
 
  //DISPLAY("r3\n");
450
 
  link_type = LINK_TIE;
451
 
  //if(link_type != prev_link_type)
452
 
  //port = VIRTUAL_PORT_2;
453
 
 
454
 
  if(gtk_toggle_button_get_active(togglebutton))
455
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
456
 
}
457
 
 
458
 
void
459
 
linktype_radiobutton4_toggled          (GtkToggleButton *togglebutton,
460
 
                                        gpointer         user_data)
461
 
{
462
 
  //DISPLAY("r4\n");
463
 
  link_type = LINK_TPU;
464
 
 
465
 
  if(gtk_toggle_button_get_active(togglebutton))
466
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
467
 
}
468
 
 
469
 
void
470
 
linktype_radiobutton5_toggled          (GtkToggleButton *togglebutton,
471
 
                                        gpointer         user_data)
472
 
{
473
 
  //DISPLAY("r5\n");
474
 
  link_type = LINK_SER;
475
 
  //if(link_type != prev_link_type)
476
 
  //port = SERIAL_PORT_2;
477
 
 
478
 
  if(gtk_toggle_button_get_active(togglebutton))
479
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
480
 
}
481
 
 
482
 
void
483
 
linktype_radiobutton6_toggled          (GtkToggleButton *togglebutton,
484
 
                                        gpointer         user_data)
485
 
{
486
 
  //DISPLAY("r6\n");
487
 
  link_type = LINK_AVR;
488
 
  //if(link_type != prev_link_type)
489
 
  //port = SERIAL_PORT_2;
490
 
 
491
 
  if(gtk_toggle_button_get_active(togglebutton))
492
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
493
 
}
494
 
 
495
 
void
496
 
linktype_radiobutton7_toggled          (GtkToggleButton *togglebutton,
497
 
                                        gpointer         user_data)
498
 
{
499
 
  //DISPLAY("r7\n");
500
 
  link_type = LINK_VTI;
501
 
  //if(link_type != prev_link_type)  
502
 
  //port = VIRTUAL_PORT_2;
503
 
 
504
 
  if(gtk_toggle_button_get_active(togglebutton))
505
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
506
 
}
507
 
 
508
 
void
509
 
linktype_radiobutton8_toggled          (GtkToggleButton *togglebutton,
510
 
                                        gpointer         user_data)
511
 
{
512
 
  //DISPLAY("r8\n");
513
 
  link_type = LINK_UGL;
514
 
  //if(link_type != prev_link_type)
515
 
  //port = USB_PORT_1;
516
 
  
517
 
  if(gtk_toggle_button_get_active(togglebutton))
518
 
    gtk_signal_emit_by_name(GTK_OBJECT(user_data), "show");
519
 
}
520
 
 
521
 
 
522
 
/************/
523
 
/* I/O port */
524
 
/************/
525
 
 
526
 
 
527
 
void
528
 
linktype_radiobutton10_toggled         (GtkToggleButton *togglebutton,
529
 
                                        gpointer         user_data)
530
 
{
531
 
  //DISPLAY("r10\n");
532
 
  switch(link_type)
533
 
    {
534
 
    case LINK_PAR:
535
 
      port = PARALLEL_PORT_1;
536
 
      break;
537
 
    case LINK_SER:
538
 
    case LINK_AVR:
539
 
    case LINK_TGL:
540
 
      port = SERIAL_PORT_1;
541
 
      break;
542
 
    case LINK_VTL:
543
 
      port = VIRTUAL_PORT_1;
544
 
      break;
545
 
    case LINK_VTI:
546
 
      port = VIRTUAL_PORT_1;
547
 
      break;
548
 
    case LINK_TIE:
549
 
      port = VIRTUAL_PORT_1;
550
 
      break;
551
 
    case LINK_TPU:
552
 
      //io_addr = TPU_RAW_MODE;
553
 
      break;
554
 
    case LINK_UGL:
555
 
      port = USB_PORT_1;
556
 
      break;
557
 
    }
558
 
}
559
 
 
560
 
 
561
 
void
562
 
linktype_radiobutton11_toggled         (GtkToggleButton *togglebutton,
563
 
                                        gpointer         user_data)
564
 
{ 
565
 
  //DISPLAY("r11\n");
566
 
  switch(link_type)
567
 
    {
568
 
    case LINK_PAR:
569
 
      port = PARALLEL_PORT_2;
570
 
      break;
571
 
    case LINK_SER:
572
 
    case LINK_AVR:
573
 
    case LINK_TGL:
574
 
      port = SERIAL_PORT_2;
575
 
      break;
576
 
    case LINK_VTL:
577
 
      port = VIRTUAL_PORT_2;
578
 
      break;
579
 
    case LINK_VTI:
580
 
      port = VIRTUAL_PORT_2;
581
 
      break;
582
 
    case LINK_TIE:
583
 
      port = VIRTUAL_PORT_2;
584
 
      break;
585
 
    case LINK_TPU:
586
 
      //io_addr = TPU_COOKED_MODE;
587
 
      break;
588
 
    case LINK_UGL:
589
 
      port = USB_PORT_2;
590
 
      break;
591
 
    }
592
 
}
593
 
 
594
 
 
595
 
void
596
 
linktype_radiobutton12_toggled         (GtkToggleButton *togglebutton,
597
 
                                        gpointer         user_data)
598
 
{  
599
 
  //DISPLAY("r12\n");
600
 
  switch(link_type)
601
 
    {
602
 
    case LINK_PAR:
603
 
      port = PARALLEL_PORT_3;
604
 
      break;
605
 
    case LINK_AVR:
606
 
    case LINK_TGL:
607
 
    case LINK_SER:
608
 
      port = SERIAL_PORT_3;
609
 
      break;
610
 
    case LINK_VTL:
611
 
      break;
612
 
    case LINK_VTI:
613
 
      break;
614
 
    case LINK_TIE:
615
 
      break;
616
 
    case LINK_TPU:
617
 
      break;
618
 
    case LINK_UGL:
619
 
      port = USB_PORT_3;
620
 
      break;
621
 
    }
622
 
}
623
 
 
624
 
 
625
 
void
626
 
linktype_radiobutton13_toggled         (GtkToggleButton *togglebutton,
627
 
                                        gpointer         user_data)
628
 
{
629
 
  //DISPLAY("r13\n");
630
 
  switch(link_type)
631
 
    {
632
 
    case LINK_PAR:
633
 
      break;
634
 
    case LINK_SER:
635
 
    case LINK_AVR:
636
 
    case LINK_TGL:
637
 
      port = SERIAL_PORT_4;
638
 
      break;
639
 
    case LINK_VTL:
640
 
      break;
641
 
    case LINK_VTI:
642
 
      break;
643
 
    case LINK_TIE:
644
 
      break;
645
 
    case LINK_TPU:
646
 
      break;
647
 
    case LINK_UGL:
648
 
      port = USB_PORT_4;
649
 
      break;
650
 
    }
651
 
}
652
 
 
653
 
 
654
 
void
655
 
linktype_radiobutton14_toggled         (GtkToggleButton *togglebutton,
656
 
                                        gpointer         user_data)
657
 
{
658
 
  //DISPLAY("r14\n");
659
 
  custom_toggled = gtk_toggle_button_get_active(togglebutton);
660
 
 
661
 
  if(custom_toggled)
662
 
    port = USER_PORT;
663
 
 
664
 
  gtk_entry_set_visibility(GTK_ENTRY(wentry1), custom_toggled);
665
 
  gtk_entry_set_editable(GTK_ENTRY(wentry1), custom_toggled ? TRUE : FALSE);
666
 
  gtk_entry_set_visibility(GTK_ENTRY(wentry2), custom_toggled);
667
 
  gtk_entry_set_editable(GTK_ENTRY(wentry2), custom_toggled ? TRUE : FALSE);
668
 
}
669
 
 
670
 
 
671
 
/*************/
672
 
/* Ok/Cancel */
673
 
/*************/
674
 
 
675
 
void
676
 
linktype_ok_button_clicked             (GtkButton       *button,
677
 
                                        gpointer         user_data)
678
 
{
679
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
680
 
 
681
 
  (options.link_cable)->method = method;
682
 
  (options.link_cable)->port = port;
683
 
  (options.link_cable)->link_type = link_type;
684
 
  (options.link_cable)->io_addr = io_addr;
685
 
  strcpy((options.link_cable)->device, device);
686
 
 
687
 
  ti68k_reconfigure_linkport();
688
 
 
689
 
  unhalt();
690
 
}
691
 
 
692
 
 
693
 
void
694
 
linktype_cancel_button_clicked         (GtkButton       *button,
695
 
                                        gpointer         user_data)
696
 
{
697
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
698
 
  unhalt();
699
 
}
700
 
 
701
 
void
702
 
on_linktype_dbox_show                  (GtkWidget       *widget,
703
 
                                        gpointer         user_data)
704
 
{
705
 
  //DISPLAY("show\n");
706
 
  if(link_type != prev_link_type)
707
 
    {
708
 
      switch(link_type)
709
 
        {
710
 
        case LINK_SER:
711
 
        case LINK_AVR:
712
 
        case LINK_TGL: port = SERIAL_PORT_2;
713
 
          break;
714
 
        case LINK_PAR: port = PARALLEL_PORT_1;
715
 
          break;
716
 
        case LINK_TIE:
717
 
        case LINK_VTI: port = VIRTUAL_PORT_2;
718
 
          break;
719
 
        case LINK_UGL: port = USB_PORT_1;
720
 
          break;
721
 
        default:
722
 
          break;
723
 
        }
724
 
      prev_link_type = link_type;
725
 
    }
726
 
}
727
 
 
728
 
void
729
 
on_linktype_button_fs_clicked            (GtkButton       *button,
730
 
                                        gpointer         user_data)
731
 
{
732
 
  gtk_widget_show(create_fileselection_device());
733
 
}
734
 
 
735
 
 
736
 
void
737
 
on_seldev_ok_button1_clicked           (GtkButton       *button,
738
 
                                        gpointer         user_data)
739
 
{
740
 
  gchar *s;
741
 
 
742
 
  s = gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data));
743
 
  gtk_entry_set_text(GTK_ENTRY(wentry2), s);
744
 
 
745
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
746
 
}
747
 
 
748
 
 
749
 
void
750
 
on_seldev_cancel_button1_clicked       (GtkButton       *button,
751
 
                                        gpointer         user_data)
752
 
{
753
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
754
 
}
755
 
 
756
 
 
757
 
void
758
 
on_fileselection_device_show           (GtkWidget       *widget,
759
 
                                        gpointer         user_data)
760
 
{
761
 
  gchar *s;
762
 
 
763
 
  s = gtk_editable_get_chars(GTK_EDITABLE(wentry2), 0, -1);
764
 
  gtk_file_selection_set_filename(GTK_FILE_SELECTION(user_data), s);
765
 
}
766
 
 
767
 
 
768
 
void
769
 
on_button2_pressed                     (GtkButton       *button,
770
 
                                        gpointer         user_data)
771
 
{
772
 
  //display_probeio_dbox();
773
 
}
774
 
 
775
 
/* */
776
 
 
777