Subversion Repositories Projects

Rev

Rev 213 | Rev 219 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
206 ligi 1
/***************************************************************
2
 *
3
 * User Interface ( Canvas ) of DUBwise
4
 *                                                          
5
 * Author:        Marcus -LiGi- Bueschleb
6
 * Mailto:        LiGi @at@ LiGi DOTT de                    
7
 *
8
 ***************************************************************/
9
 
10
import javax.microedition.lcdui.*;
11
 
12
 
13
import javax.microedition.media.*;
14
import javax.microedition.media.control.*;
15
 
16
 
17
//#if fileapi=="on"
18
import javax.microedition.io.*;
19
import javax.microedition.midlet.*;
20
import javax.microedition.io.file.*;
21
 
22
import java.io.*;
23
import java.util.*;
24
//#endif
25
 
26
public class DUBwiseCanvas
27
    extends Canvas
211 ligi 28
    implements Runnable,org.ligi.ufo.DUBwiseDefinitions , DUBwiseUIDefinitions
206 ligi 29
{
30
 
31
//#if fileapi=="on"
32
    public final static int MAX_FILELIST_LENGTH=100;
33
    public final static int MAX_PATH_DEPTH=10;
34
 
35
    byte act_path_depth=0;
36
    String[] act_path_arr;
37
 
38
 
39
    public String act_path()
40
    {
41
        String res="";
42
        for (int i=0;i<act_path_depth;i++)
43
            res+=act_path_arr[i];
44
        return res;
45
    }
46
 
47
    String[] file_list;
48
    int file_list_length=0;
49
//#endif
50
 
213 ligi 51
    String act_input_str=" ";
52
 
206 ligi 53
    boolean ipinput4proxy;
54
    byte ipinput_pos=0;
55
    int[] act_edit_ip;
56
 
57
    int canvas_width=100;
58
    int canvas_height=100;
59
 
60
 
61
    //    public String ip_digit_zeroes(int digit)
62
    //{ return "" + digit/100 + "" +   (digit/10)%10 + "" + (digit)%10;   }
63
 
64
 
65
 
66
    int heading_offset=0;
67
    int act_wp;
68
 
69
 
70
 
71
//#if bluetooth=="on"
72
    private BTSearcher bt_scanner;
73
//#endif
74
 
75
    public org.ligi.ufo.MKCommunicator mk=null;
76
    //    private MKStatistics mk_stat=null;
77
    private MKParamsEditor params_editor=null;
78
    public DUBwiseDebug debug=null;
79
    public DUBwiseHelper helper=null;
80
 
81
 
82
//#if voice_mode!="no_voice"
83
    private MKStatusVoice status_voice;
84
//#endif
85
 
86
 
87
    private DUBwise root;
88
    public DUBwiseSettings settings;
89
    //    public UFOProber mk.ufo_prober;
90
 
91
    private Image bg_img;
92
    private Image lcd_img;
93
    private Image symbols_img;
94
    private Image err_img;
95
 
96
 
97
    int max_lines;
98
 
99
 
100
    public byte act_motor=0;
101
    public byte act_motor_increase=0;
102
    public boolean motor_test_sel_all=false;
103
 
104
 
105
    /* Graph Vars */
106
    public final static int GRAPH_COUNT=4;
107
    public final static int[] graph_colors={0x156315,0xCC1315,0xf8ef02,0x19194d};
108
    public int[] graph_sources={0,1,2,3};
109
    public String[] graph_names={"nick int","roll int","nick acc","roll acc"};
110
    public int[][] graph_data;
111
 
112
    public int lcd_char_width=0;
113
    public int lcd_char_height=0;
114
 
115
    public int frame_pos=0;
116
 
117
    //    public byte mk.user_intent=USER_INTENT_NONE;
118
 
119
    int line_scaler=20;
120
 
121
    int rawdebug_cursor_y=0;    
122
    int rawdebug_off_y=0;
123
 
124
    public int line_middle_y;
125
 
126
    boolean quit=false;
127
 
128
    int     bg_offset=0;
129
 
130
    // variable to hold the current state
131
    public byte state=-1;
132
 
133
    int local_max=-1;
134
 
135
    int y_off=0;
136
    int spacer=0;
137
    int spacer1=0;
138
 
139
    int[] motor_test = {0,0,0,0};
140
 
141
 
142
    String[] menu_items;
143
    byte[]    menu_actions;
144
    int act_menu_select=0;
145
 
146
    String[] lcd_lines =null;
147
 
148
 
214 ligi 149
 
150
    //    boolean expert_mode=false;
151
 
152
    public void setup_main_menu()
153
    {
154
        byte     setup_pos=0;
155
        byte[]   tmp_actions=new byte[20];
156
        String[] tmp_items=new String[20];
157
 
158
 
159
 
160
        tmp_actions[setup_pos]=ACTIONID_SETTINGS;
161
        tmp_items[setup_pos++]  ="Tool Settings";
162
 
163
 
164
        tmp_actions[setup_pos]=ACTIONID_CONN_DETAILS;
165
        tmp_items[setup_pos++]  ="Connection";
166
 
167
        if (settings.expert_mode)
168
            {
169
                tmp_actions[setup_pos]=ACTIONID_DEBUG;
170
                tmp_items[setup_pos++]  ="Debug";
171
 
172
            }
173
 
174
 
175
 
176
        if (mk.ufo_prober.is_mk()  )
177
            {
178
                tmp_actions[setup_pos]=ACTIONID_MOTORTEST;
179
                tmp_items[setup_pos++]  ="Motor Test";
180
 
181
                tmp_actions[setup_pos]=ACTIONID_KEYCONTROL;
182
                tmp_items[setup_pos++]  ="Key-Control";
183
 
184
                tmp_actions[setup_pos]=ACTIONID_RCDATA;
185
                tmp_items[setup_pos++]  ="view RC-data";
186
 
187
                tmp_actions[setup_pos]=ACTIONID_EDIT_PARAMS;
188
                tmp_items[setup_pos++]  ="Flight Settings";
189
            }
190
 
191
 
192
 
193
        if (( mk.ufo_prober.is_navi()||mk.ufo_prober.is_mk()  ))
194
            {
195
                tmp_actions[setup_pos]=ACTIONID_LCD;
196
                tmp_items[setup_pos++]  ="LCD";
197
            }
198
 
199
        if (( mk.ufo_prober.is_mk()  ))
200
            {
201
                tmp_actions[setup_pos]=ACTIONID_GRAPH;
202
                tmp_items[setup_pos++]  ="Graph";
203
            }
204
 
205
 
206
 
207
 
208
        if (( mk.ufo_prober.is_navi()||mk.ufo_prober.is_mk()||mk.ufo_prober.is_mk3mag() ))
209
            {
210
                tmp_actions[setup_pos]=ACTIONID_RAWDEBUG;
211
                tmp_items[setup_pos++]  ="Debug Values";
212
            }
213
 
214
 
215
 
216
        if ( mk.ufo_prober.is_navi())
217
            {
218
                tmp_actions[setup_pos]=ACTIONID_GPSDATA;
219
                tmp_items[setup_pos++]  ="view GPS-Data";
220
 
221
                tmp_actions[setup_pos]=ACTIONID_NC_ERRORS;
222
                tmp_items[setup_pos++]  ="view Errors";
223
 
224
 
225
                tmp_actions[setup_pos]=ACTIONID_SWITCH_FC;
226
                tmp_items[setup_pos++]  ="switch to FC";
227
 
228
                tmp_actions[setup_pos]=ACTIONID_SWITCH_MK3MAG;
229
                tmp_items[setup_pos++]  ="switch to MK3MAG";
230
 
231
            }
232
 
233
        if ((mk.ufo_prober.is_mk()||mk.ufo_prober.is_mk3mag() ))
234
            {
235
                tmp_actions[setup_pos]=ACTIONID_SWITCH_NC;
236
                tmp_items[setup_pos++]  ="switch to Navi";
237
            }
238
 
239
 
240
        if ((settings.expert_mode)&& ( mk.ufo_prober.is_navi()||mk.ufo_prober.is_mk()||mk.ufo_prober.is_mk3mag()||mk.ufo_prober.is_incompatible()   ))
241
            {
242
                tmp_actions[setup_pos]=ACTIONID_FLASH;
243
                tmp_items[setup_pos++]  ="Flash Firmware";
244
            }
245
 
246
        if ((settings.expert_mode)&& ( mk.ufo_prober.is_mk()   ))
247
            {
248
                tmp_actions[setup_pos]=ACTIONID_CAM;
249
                tmp_items[setup_pos++]  ="Remote Cam";
250
            }
251
 
252
 
253
 
254
        tmp_actions[setup_pos]=ACTIONID_ABOUT;
255
        tmp_items[setup_pos++]  ="About";
256
 
257
        tmp_actions[setup_pos]=ACTIONID_QUIT;
258
        tmp_items[setup_pos++]  ="Quit";
259
 
260
 
261
        byte[]   tmp_actions_fin=new byte[setup_pos];
262
        String[] tmp_items_fin=new String[setup_pos];
263
 
264
        for ( int tmp_p=0;tmp_p<setup_pos;tmp_p++)
265
            {
266
                tmp_actions_fin[tmp_p]=tmp_actions[tmp_p];
267
                tmp_items_fin[tmp_p]  =tmp_items[tmp_p];
268
            }
269
        setup_menu(tmp_items_fin,tmp_actions_fin);
270
    }
271
 
272
 
206 ligi 273
    public void setup_menu(String[] items , byte[] actions)
274
    {
275
        menu_items=items;
276
        menu_actions=actions;
277
        lcd_lines=new String[menu_items.length];
278
    }
279
 
280
    public void paint_menu(Graphics g)
281
    {
282
        for ( int i=0;i<menu_items.length;i++)
283
            {
284
                if ((frame_pos%3)!=0)
285
                    {
286
                        lcd_lines[i]=(act_menu_select==i?">":" ") + menu_items[i];     
287
                        for ( int ii=0;ii<(18-menu_items[i].length());ii++)
288
                            lcd_lines[i]+=" ";
289
                        if (act_menu_select==i)
290
                            lcd_lines[i]+="<";
291
                    }
292
                else
293
                    lcd_lines[i]=" " + menu_items[i];  
294
 
295
 
296
            }
297
        paint_lcd(g,true);
298
    }
299
 
300
    public void menu_keypress(int keyCode)
301
    {
302
        debug.log("Menu with KeyCode:"+keyCode);
303
        switch (getGameAction (keyCode))
304
            {
305
            case UP:
306
                if (act_menu_select!=0) act_menu_select--;
307
                else
308
                    act_menu_select=menu_items.length-1;
309
                break;
310
 
311
            case DOWN:
312
                if (act_menu_select<(menu_items.length-1)) act_menu_select++;
313
                else act_menu_select=0;
314
                break;
315
 
316
            }
317
 
318
    }
319
 
320
    public boolean cam_condition()
321
    {
322
        return (mk.stick_data.stick[5]>100);
323
    }
324
 
325
    //    int lcd_top=25;
326
 
327
    public void paint_lcd(Graphics g,boolean bottomup)
328
    {
329
 
330
        int y;
331
 
332
        int lcd_top= (state==STATEID_EDIT_PARAMS?0:25);
333
        max_lines=(canvas_height-lcd_top)/lcd_char_height;
334
 
335
        int spacer_left_right=(canvas_width-(20*(lcd_img.getWidth()/222)))/2;
336
        //      for(int i=0;i<lcd_lines.length;i++)
337
 
338
        int display_lines=(lcd_lines.length>max_lines?max_lines:lcd_lines.length);
339
 
340
 
341
        int lcd_off= (state==STATEID_EDIT_PARAMS?params_editor.act_y:act_menu_select)-display_lines+1;
342
        if ( lcd_off<0)  lcd_off=0;
343
 
344
        for(int i=0;i<display_lines;i++)
345
            for (int pos=0;pos<20;pos++)
346
            {
347
                if (bottomup)
348
                    y=canvas_height-(display_lines-i)*lcd_char_height;
349
                else
350
                    y=i*lcd_char_height;
351
                g.setClip((lcd_img.getWidth()/222)*pos+spacer_left_right,y,(lcd_img.getWidth()/222),lcd_img.getHeight());
352
                g.drawImage(lcd_img,spacer_left_right+(lcd_img.getWidth()/222)*pos-((pos<lcd_lines[i+lcd_off].length()?lcd_lines[i+lcd_off].charAt(pos):' ')-' ')*(lcd_img.getWidth()/222),y,g.TOP | g.LEFT);
353
 
354
            }
355
    }
356
 
357
    public void load_images()
358
    {
359
        try
360
            {
361
                bg_img=null;
362
                lcd_img=null;
363
 
364
                // load all needed images
365
                switch (settings.act_skin)
366
                    {
367
                    case SKINID_DARK:
368
                        lcd_img=Image.createImage("/lcd_green.png");
369
                        if (settings.do_scrollbg) bg_img=Image.createImage("/starfield.jpg");                                   break;
370
 
371
                    case SKINID_LIGHT:
372
                        lcd_img=Image.createImage("/lcd_blue.png");
373
                        if (settings.do_scrollbg) bg_img=Image.createImage("/clouds.jpg");
374
                        break;
375
                    }
376
 
377
 
378
                //              bt_img=Image.createImage("/bt.png");
379
                symbols_img=Image.createImage("/symbols.png");
380
  //            load_img=Image.createImage("/load.png");
381
 
382
                lcd_char_width=lcd_img.getWidth()/222;
383
                lcd_char_height=lcd_img.getHeight();
384
 
385
 
386
 
387
                if (bg_img!=null)
388
                    graph_data=new int[GRAPH_COUNT][bg_img.getWidth()];
389
                else
390
                    graph_data=new int[GRAPH_COUNT][this.getWidth()*2];
391
 
392
                for (int c=0;c<graph_data[0].length;c++)
393
                    for (int d=0;d<GRAPH_COUNT;d++)
394
                        graph_data[d][c]=-1;
214 ligi 395
 
206 ligi 396
                try {
397
                    err_img=null;
214 ligi 398
                    err_img=Image.createImage("/preflight.jpg");           
206 ligi 399
                }
400
                catch (Exception e)         {    }
401
 
402
            }
403
 
404
        catch (Exception e)
405
            {
406
                debug.err(e.toString());
407
            }
408
 
409
    }
410
 
411
    public DUBwiseCanvas(DUBwise _root)
412
    {
413
 
414
//#if fileapi=="on"
415
        file_list= new String[MAX_FILELIST_LENGTH];
416
        act_path_arr=new String[MAX_PATH_DEPTH];
417
//#endif
418
 
419
        root=_root;
420
 
421
        mk      = new org.ligi.ufo.MKCommunicator();
422
        helper = new DUBwiseHelper();
423
        settings = new DUBwiseSettings();
424
        debug   = new DUBwiseDebug(this);
425
 
426
//#if bluetooth=="on"
427
        bt_scanner = new BTSearcher();
428
//#endif
429
 
430
        params_editor = new MKParamsEditor(this);
431
 
432
//#if voice_mode!="no_voice"
433
        status_voice=new MKStatusVoice(mk,this);
434
//#endif
435
 
436
 
437
        load_images();
438
 
439
        if (settings.connection_url!="")
440
            connect_mk(settings.connection_url,settings.connection_name);
211 ligi 441
 
442
        mk.gps_position.act_speed_format=settings.speed_format;
443
        mk.gps_position.act_gps_format= settings.gps_format;
206 ligi 444
 
211 ligi 445
 
206 ligi 446
        chg_state(STATEID_MAINMENU);
447
 
448
        new Thread(this).start();
449
 
450
    }
451
 
452
 
453
 
454
 
455
    /****************************** Thread ******************/
456
    // ticking runnable Section
457
    public void run()
458
    {
459
 
460
 
461
        while(true)
462
            {
463
                try {
464
 
465
 
466
                repaint();
467
                serviceRepaints();
468
 
469
                System.gc();
470
                long loopStartTime = System.currentTimeMillis();
471
                long sleeptime=0;
472
                // ticked thing
473
 
474
                frame_pos++;
475
 
476
                if (mk.ufo_prober.change_notify)
477
                    {
478
                        mk.ufo_prober.change_notify=false;
479
                        if (mk.ufo_prober.is_incompatible())
480
                            {
481
                                mk.error_str="incompatible Device";
482
                                chg_state(STATEID_NC_ERRORS);
483
                            }
484
                        else
485
                            if (state==STATEID_MAINMENU)
486
                                chg_state(STATEID_MAINMENU); // reload mainmenu ( changed content )
487
                    }
488
 
211 ligi 489
 
206 ligi 490
                switch(state)
491
                    {
492
                    case STATEID_CAMMODE:
211 ligi 493
 
494
                        try
495
                            {
496
                                if(cam_condition())
497
                                    {
206 ligi 498
                                        cam_img=null;
499
                                        debug.log("get snap\n");
500
                                        cam_raw = mVideoControl.getSnapshot(null);
211 ligi 501
 
206 ligi 502
                                        try { Thread.sleep(4000); }
503
                                        catch (Exception e)
504
                                            {
505
                                                debug.log("Problem Sleeping ");
211 ligi 506
 
206 ligi 507
                                            }
211 ligi 508
                                    }
509
                                else
510
                                    {
511
                                        if (cam_img==null)
512
                                            cam_img = Image.createImage(cam_raw, 0, cam_raw.length);
513
                                    }
514
                            }
515
                        catch ( Exception e)
516
                            {
517
                                debug.log(e.toString());
518
                            }
206 ligi 519
                        break;
520
                    case STATEID_KEYCONTROL:
521
                        mk.send_keys(keycontrol_bitfield);     
522
                        break;
211 ligi 523
 
206 ligi 524
                    case STATEID_NC_ERRORS:
525
                        lcd_lines[0]=""+mk.error_str;
526
                        break;
211 ligi 527
 
206 ligi 528
                    case STATEID_READ_PARAMS:
529
                        if (mk.watchdog.act_paramset==5)
530
                            chg_state(STATEID_SELECT_PARAMSET);
531
                        else
532
                            {
533
                                lcd_lines[0]="Reading Settings    ";
534
                                lcd_lines[1]=mk.watchdog.act_paramset+"/5 |"+ (mk.watchdog.act_paramset>0?"#":"_") + (mk.watchdog.act_paramset>1?"#":"_") + (mk.watchdog.act_paramset>2?"#":"_")+ (mk.watchdog.act_paramset>3?"#":"_")+ (mk.watchdog.act_paramset>4?"#":"_") + "|         ";
211 ligi 535
 
206 ligi 536
                                if (mk.params.found_incompatible)
537
                                    {
538
                                        mk.error_str="incompatible params";
539
                                        chg_state(STATEID_NC_ERRORS);
540
                                    }
211 ligi 541
 
206 ligi 542
                            }
543
                        break;
211 ligi 544
 
206 ligi 545
 
546
                    case STATEID_MOTORTEST:
547
 
548
                        if (motor_test_sel_all)
549
                            for (int m=0;m<4;m++)
550
                                {
551
                                    motor_test[m]+=act_motor_increase;
552
                                    if (motor_test[m]<0)motor_test[m]=0;
553
                                    if (motor_test[m]>255)motor_test[m]=255;
554
                                }
555
                        else
556
                            {
557
                                motor_test[act_motor]+=act_motor_increase;
558
                                if (motor_test[act_motor]<0) motor_test[act_motor]=0;
559
                                if (motor_test[act_motor]>255) motor_test[act_motor]=255;
560
                            }
561
 
562
                        mk.motor_test(motor_test);
563
                        break;
564
 
213 ligi 565
                    case STATEID_STRINGINPUT:
566
 
567
                        lcd_lines[0]=act_input_str;
568
                        for(int tmp_i=act_input_str.length();tmp_i<20;tmp_i++)
569
                            lcd_lines[0]+=(char)(0);
570
 
571
                        lcd_lines[1]="";
572
                        for(int foo=0;foo<20;foo++)
573
                            {
574
                                if (foo==ipinput_pos)
575
                                    lcd_lines[1]+="^";
576
                                else
577
                                    lcd_lines[1]+=" ";
578
                            }
579
                        break;
580
 
581
 
206 ligi 582
                    case STATEID_IPINPUT:
583
                        if (ipinput4proxy)
584
                            act_edit_ip=settings.act_proxy_ip;
585
                        else
586
                            act_edit_ip=settings.act_conn_ip;                      
587
 
588
                        lcd_lines[1]=helper.ip_str(act_edit_ip,true);
589
 
590
 
591
                        lcd_lines[2]="";
592
                        for(int foo=0;foo<20;foo++)
593
                            {
594
                                if (foo==ipinput_pos)
595
                                    lcd_lines[2]+="^";
596
                                else
597
                                    lcd_lines[2]+=" ";
598
                            }
599
                        break;
600
 
601
                    case STATEID_MAINMENU:
602
 
603
                        break;
604
 
605
//#if bluetooth=="on"
606
                    case STATEID_SCANNING:
211 ligi 607
 
608
                        lcd_lines[1]="Bluetooth Devices " + idle_seq[(((frame_pos/5)%idle_seq.length))];
206 ligi 609
                        lcd_lines[2]="found " + bt_scanner.remote_device_count;
610
 
611
                        if (!bt_scanner.searching)
612
                                chg_state(STATEID_DEVICESELECT);
613
 
614
                        break;
615
//#endif
616
 
617
 
618
                    }
619
 
620
                if (quit)
621
                    {
211 ligi 622
                        settings.speed_format=mk.gps_position.act_speed_format;
623
                        settings.gps_format=mk.gps_position.act_gps_format;
206 ligi 624
                        settings.save();
625
                        root.quit();
626
                    }
627
 
628
                try {
629
                    //rescan=false;
630
                    bg_offset--;
631
                    if (bg_offset==-graph_data[0].length)
632
                        bg_offset=0;
633
//#if devicecontrol=="on"
634
                    if (settings.keep_lighton) com.nokia.mid.ui.DeviceControl.setLights(0,100);
635
//#endif
636
                }
637
                catch (Exception e)   {    }
638
 
639
 
640
                sleeptime=1000/ 15 - (int) (System.currentTimeMillis()- loopStartTime);
641
 
642
                if (sleeptime<0)
643
                    sleeptime=100; // everyone has fi sleep
644
 
645
                try { Thread.sleep(sleeptime); }
646
                catch (Exception e)
647
                    {
648
                        debug.log("Problem Sleeping ");
649
                    }
650
 
651
                }
652
                catch (Exception e)
653
                    {
654
                        debug.log("E!:"+e.getMessage());
655
 
656
                    }
657
            }
658
    }
659
 
660
 
661
 
662
    boolean firstrun=true;
663
 
664
    public int skin_bg_color()
665
    {
666
 
667
        switch (settings.act_skin)
668
            {
669
            case SKINID_DARK:
670
                return 0x000000;       
671
 
672
            default:           
673
            case SKINID_LIGHT:
674
                return 0xFFFFFF;       
675
            }
676
    }
677
 
678
 
679
    public int skin_fg_color()
680
    {
681
 
682
        switch (settings.act_skin)
683
            {
684
            case SKINID_DARK:
685
                return 0xFFFFFF;       
686
 
687
            default:
688
            case SKINID_LIGHT:
689
                return 0x000000;       
690
            }
691
    }
692
 
693
    // drawing section
694
    public void paint(Graphics g) {
695
 
696
        canvas_width=this.getWidth();
697
        canvas_height=this.getHeight();
698
 
699
        if (debug.showing)
700
            {
701
                debug.paint(g);
702
                return;
703
            }
704
 
705
 
706
        if (firstrun)
707
            {
708
                if (settings.fullscreen) setFullScreenMode(settings.fullscreen);
709
                firstrun=false;
710
            }
711
        y_off=0;
712
 
713
 
714
 
715
        try {
716
 
717
            if (mk!=null)
718
                {
719
                    line_middle_y=canvas_height/2;
720
                    if (local_max<Math.abs(mk.debug_data.nick_int()))
721
                        local_max=Math.abs(mk.debug_data.nick_int());
722
                    if (local_max<Math.abs(mk.debug_data.roll_int()))
723
                        local_max=Math.abs(mk.debug_data.roll_int());
724
                    if (local_max<Math.abs(mk.debug_data.accnick()))
725
                        local_max=Math.abs(mk.debug_data.accnick());
726
                    if (local_max<Math.abs(mk.debug_data.accroll()))
727
                        local_max=Math.abs(mk.debug_data.accroll());
728
                    line_scaler= local_max/(canvas_height/2)+1;
729
                }
730
 
731
 
732
            Font f1 = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);  
733
            Font f2 = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_SMALL);  
734
 
735
            spacer=(f1.getHeight());
736
            spacer1=(f2.getHeight());
737
 
738
            //default Font
739
            g.setFont(f1);
740
 
741
 
742
            //draw background
743
            if ((!settings.do_scrollbg) || (state==STATEID_EDIT_PARAMS))
744
                {
745
                    g.setColor(0xdedfff);
746
                    g.fillRect(0,0,canvas_width,symbols_img.getHeight());
747
 
748
                    g.setColor(skin_bg_color());
749
                    g.fillRect(0,symbols_img.getHeight(),canvas_width,canvas_height-symbols_img.getHeight());
750
 
751
 
752
                }
753
            else
754
                {
755
                    g.setColor(0xFFFFFF);
756
                    g.fillRect(0,0,canvas_width,canvas_height);
757
                    g.drawImage(bg_img,bg_offset,0, g.TOP | g.LEFT);
758
 
759
                    if (bg_offset+bg_img.getWidth()<canvas_width)
760
                        g.drawImage(bg_img,bg_offset+bg_img.getWidth(),0, g.TOP | g.LEFT);
761
                }
762
 
763
 
764
            //int bar=0;
765
            //      for ( int bar=0;bar<3;bar++)
766
            if (settings.do_scrollbg)
767
                for ( int bar=0;bar<canvas_width/(symbols_img.getWidth()/10)+1;bar++)
768
                    {
769
                        g.setClip(bar*(symbols_img.getWidth()/10),0,(symbols_img.getWidth()/10),symbols_img.getHeight());;
770
                        g.drawImage(symbols_img,bar*(symbols_img.getWidth()/10),0, g.TOP | g.LEFT);
771
                    }
772
 
773
            int symbol_left=0;
774
 
775
            g.setClip(symbol_left,0,(symbols_img.getWidth()/10),symbols_img.getHeight());;
776
            if ((mk.ufo_prober.is_navi()||mk.ufo_prober.is_mk()))
777
                {
778
 
779
                    if (((mk.stats.bytes_in>>3)&1)==1)
780
                    g.drawImage(symbols_img,(-2)*(symbols_img.getWidth()/10),0, g.TOP | g.LEFT);           
781
                    else
782
                    g.drawImage(symbols_img,(-3)*(symbols_img.getWidth()/10),0, g.TOP | g.LEFT);           
783
 
784
 
785
                    int symbol_spacer=5;
786
                    symbol_left+=symbol_spacer+(symbols_img.getWidth()/10);
787
                    g.setClip(symbol_left,0,(symbols_img.getWidth()/10),symbols_img.getHeight());;
788
 
789
                    g.drawImage(symbols_img,symbol_left+(-4)*(symbols_img.getWidth()/10),0, g.TOP | g.LEFT);                       
790
                    g.setClip(0,0,canvas_width,canvas_height);
791
                    g.setColor(0x03035a);
792
 
793
                    symbol_left+=2+(symbols_img.getWidth()/10);
794
                    g.drawString("" + (mk.UBatt()/10) + "," +(mk.UBatt()%10)+"V" , symbol_left,y_off,Graphics.TOP | Graphics.LEFT);
795
 
796
 
797
                    symbol_left+=           g.getFont().stringWidth("88,8V");//;
798
                    g.setClip(symbol_left,0,(symbols_img.getWidth()/10),symbols_img.getHeight());
799
                    g.drawImage(symbols_img,(-6)*(symbols_img.getWidth()/10) +   symbol_left,0, g.TOP | g.LEFT);                           
800
 
801
                    g.setClip(0,0,canvas_width,canvas_height);
802
 
803
                    symbol_left+=2+(symbols_img.getWidth()/10);
804
                    g.drawString(""+mk.SenderOkay() ,symbol_left,y_off,Graphics.TOP | Graphics.LEFT);
805
 
806
 
807
                    symbol_left+=           g.getFont().stringWidth("8")+symbol_spacer; //,0,(symbols_img.getWidth()/10)+2;
808
 
809
 
810
 
811
 
812
                    if (mk.ufo_prober.is_navi())
813
                        {
814
 
815
 
816
                            g.setClip(symbol_left,0,(symbols_img.getWidth()/10),symbols_img.getHeight());
817
                            g.drawImage(symbols_img,(-5)*(symbols_img.getWidth()/10) +   symbol_left,0, g.TOP | g.LEFT);                           
818
                    g.setClip(0,0,canvas_width,canvas_height);
819
                            symbol_left+=2+(symbols_img.getWidth()/10);
820
                            g.drawString(""+mk.gps_position.SatsInUse ,symbol_left,y_off,Graphics.TOP | Graphics.LEFT);
821
 
822
                        }
823
 
824
                }
825
 
826
            else
827
            g.drawImage(symbols_img,(-1)*(symbols_img.getWidth()/10),0, g.TOP | g.LEFT);           
828
 
829
            //      if (mk.connected)
830
 
831
 
832
            // unclip
833
            g.setClip(0,0,canvas_width,canvas_height);
834
 
835
            y_off+=symbols_img.getHeight();
836
            g.setColor(skin_fg_color());
837
 
838
            switch(state)
839
                {
840
 
841
 
842
                case STATEID_DATABUFF:
843
                    g.setFont(f2);
844
 
845
                    y_off=canvas_height-spacer1;
846
 
847
                    for (int pos_y=0;pos_y<(((canvas_height-spacer1)/spacer1));pos_y++)
848
                        {
849
 
850
                            g.drawString(mk.get_buff(pos_y) ,0,y_off,Graphics.TOP | Graphics.LEFT);
851
                            y_off-=spacer1;
852
                        }
853
                    break;
854
                case STATEID_NC_ERRORS:
214 ligi 855
                    if (err_img!=null)
206 ligi 856
                        {
857
                            int err_img_left=(canvas_width-err_img.getWidth()/2)/2;
858
                            int err_img_top=(canvas_height-err_img.getHeight())/2;
859
                            g.setClip(err_img_left,err_img_top,err_img.getWidth()/2,err_img.getHeight());
860
                            g.drawImage(err_img,err_img_left-err_img.getWidth()/2,err_img_top, g.TOP | g.LEFT);
861
                        }
862
                            paint_lcd(g,true);
863
 
864
                    break;
865
 
866
                case STATEID_GPSVIEW:
867
 
868
                    g.setFont(f2);
869
 
870
                    g.setStrokeStyle(Graphics.SOLID);  
871
                    g.setColor(0x0000ff);  
872
 
873
 
874
                    //              g.fillArc(0, 0, canvas_width, canvas_width, 0,45); 
875
 
876
/*
877
  int start_angle=(360+mk.gps_position.angle2wp(act_wp) - ((360+mk.debug_data.analog[26]-heading_offset)%360))%360;
878
                    //              start_angle=0;
879
                    start_angle=(360-start_angle +90 -(45/2))%360;
880
 
881
                    g.fillArc(0, 0, canvas_width, canvas_width, start_angle,45);
882
*/
883
                    //              g.drawArc(1, 1, canvas_width-2, canvas_width-2, start_angle,45); 
884
                    // g.drawArc(2, 2, canvas_width-4, canvas_width-4, start_angle  ,45); 
885
 
886
 
887
                    g.setColor(skin_fg_color());
888
 
889
                    g.drawString("Used Sats: " + mk.gps_position.SatsInUse + " | Packages: " + mk.stats.navi_data_count ,0,y_off,Graphics.TOP | Graphics.LEFT);  
890
                    y_off+=spacer1;
891
 
892
                    g.drawString("Lat: " + mk.gps_position.Latitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
893
                    y_off+=spacer1;
894
 
895
                    g.drawString("Long: " + mk.gps_position.Longitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
896
                    y_off+=spacer1;
897
 
898
                    g.drawString("Altitude: " + mk.gps_position.Altitude ,0,y_off,Graphics.TOP | Graphics.LEFT);
899
                    y_off+=spacer1;
211 ligi 900
 
901
                    g.drawString("GrSpeed: " + mk.gps_position.GroundSpeed_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
902
                    y_off+=spacer1;
903
 
904
                    g.drawString("Heading: " + mk.gps_position.Heading ,0,y_off,Graphics.TOP | Graphics.LEFT);
905
                    y_off+=spacer1;
906
 
907
                    g.drawString("CompasHeading: " + mk.gps_position.CompasHeading ,0,y_off,Graphics.TOP | Graphics.LEFT);
908
                    y_off+=spacer1;
206 ligi 909
 
910
 
911
                    g.drawString("Target-Lat: " + mk.gps_position.TargetLatitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
912
                    y_off+=spacer1;
913
                    g.drawString("Target-Long: " + mk.gps_position.TargetLongitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
914
                    y_off+=spacer1;
915
 
916
                    g.drawString("Target-Alt: " + mk.gps_position.TargetAltitude ,0,y_off,Graphics.TOP | Graphics.LEFT);
917
                    y_off+=spacer1;
918
 
919
 
920
                    g.drawString("Home-Lat: " + mk.gps_position.HomeLatitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
921
                    y_off+=spacer1;
922
 
923
                    g.drawString("Home-Long: " + mk.gps_position.HomeLongitude_str() ,0,y_off,Graphics.TOP | Graphics.LEFT);
924
                    y_off+=spacer1;
925
 
926
                    g.drawString("Home-Alt: " + mk.gps_position.HomeAltitude ,0,y_off,Graphics.TOP | Graphics.LEFT);
927
 
928
                    y_off+=spacer1;
929
                    g.drawString("Distance : " + mk.gps_position.Distance2Target ,0,y_off,Graphics.TOP | Graphics.LEFT);
930
                    y_off+=spacer1;
931
                    g.drawString("Angle: " + mk.gps_position.Angle2Target ,0,y_off,Graphics.TOP | Graphics.LEFT);
932
                    y_off+=spacer1;
933
 
934
                    g.drawString("WayPoints: " + mk.gps_position.WayPointNumber + "/" +  mk.gps_position.WayPointIndex ,0,y_off,Graphics.TOP | Graphics.LEFT);
935
                    y_off+=spacer;
936
 
937
 
938
 
939
                    /*
940
                      g.drawString("" +  mk.gps_position.NameWP[act_wp] ,0,y_off,Graphics.TOP | Graphics.LEFT);
941
                    y_off+=spacer;
942
 
943
                    g.drawString("Lat: " +  mk.gps_position.WP_Latitude_str(act_wp) ,0,y_off,Graphics.TOP | Graphics.LEFT);
944
                    y_off+=spacer;
945
 
946
                    g.drawString("Long: " +  mk.gps_position.WP_Longitude_str(act_wp) ,0,y_off,Graphics.TOP | Graphics.LEFT);
947
                    y_off+=spacer;
948
 
949
 
950
                    g.drawString("Distance: " +  mk.gps_position.distance2wp(act_wp) ,0,y_off,Graphics.TOP | Graphics.LEFT);
951
                    y_off+=spacer;
952
 
953
                    g.drawString("Angle: " +  mk.gps_position.angle2wp(act_wp) ,0,y_off,Graphics.TOP | Graphics.LEFT);
954
                    y_off+=spacer;
955
 
956
                    g.drawString("Compas Heading: " +  (360+mk.debug_data.analog[26]-heading_offset)%360) + "("  +mk.debug_data.analog[26] +")" ,0,y_off,Graphics.TOP | Graphics.LEFT);
957
                    y_off+=spacer;
958
                    */
959
 
960
 
961
                    break;
962
 
963
                case STATEID_FLASHING:
964
                    int msg_pos=0;
965
                    while (mk.flash_msgs[msg_pos]!=null)
966
                        {
967
                            g.drawString(mk.flash_msgs[msg_pos] ,0,y_off,Graphics.TOP | Graphics.LEFT);
968
                            y_off+=spacer;
969
                            msg_pos++;
970
                        }
971
                    break;
972
 
973
                case STATEID_CAMMODE:
974
 
975
                    if (cam_img!=null)
976
                        g.drawImage(cam_img,0,0,g.TOP | g.LEFT);
977
                        g.drawString("condition: " + cam_condition() ,0,y_off,Graphics.TOP | Graphics.LEFT);
978
                        y_off+=spacer;
979
                        g.drawString("width " + cam_img.getWidth(),0,y_off,Graphics.TOP | Graphics.LEFT);
980
                        y_off+=spacer;
981
                        g.drawString("height " + cam_img.getHeight(),0,y_off,Graphics.TOP | Graphics.LEFT);
982
                        y_off+=spacer;
983
                        break;
984
 
985
                case STATEID_STICKVIEW:
986
 
987
                    for(int tmp_y=0;tmp_y<10;tmp_y++)
988
                        {
989
                            g.drawString(""+tmp_y+"(" + mk.params.stick_names[tmp_y] + ")=>"+mk.stick_data.stick[tmp_y],0,y_off,Graphics.TOP | Graphics.LEFT);
990
                            y_off+=spacer;
991
                        }
992
                    break;
993
 
994
                case STATEID_KEYCONTROL:
995
 
996
 
997
                    y_off+=spacer;
998
                    g.drawString("UP&DOWN => nick",0,y_off,Graphics.TOP | Graphics.LEFT);
999
                    y_off+=spacer;
1000
                    g.drawString("LEFT&RIGHT => roll",0,y_off,Graphics.TOP | Graphics.LEFT);
1001
                    y_off+=spacer;
1002
                    g.drawString("1&4 => altitude",0,y_off,Graphics.TOP | Graphics.LEFT);
1003
 
1004
                    y_off+=spacer;
1005
                    g.drawString("2&3 => gier",0,y_off,Graphics.TOP | Graphics.LEFT);
1006
 
1007
                    y_off+=spacer;
1008
                    g.drawString("Press # and * at once",0,y_off,Graphics.TOP | Graphics.LEFT);
1009
                    y_off+=spacer;
1010
                    g.drawString("to quit KeyControl",0,y_off,Graphics.TOP | Graphics.LEFT);
1011
                    y_off+=spacer;
1012
                    g.drawString("bf1:"+ keycontrol_bitfield[0] ,0,y_off,Graphics.TOP | Graphics.LEFT);
1013
                    g.drawString("bf2:"+ keycontrol_bitfield[1] ,canvas_width/2,y_off,Graphics.TOP | Graphics.LEFT);
1014
 
1015
                    break;
1016
 
1017
                case STATEID_MOTORTEST:
1018
                    for (int bar=0;bar<4;bar++)
1019
 
1020
                        {
1021
                            g.setColor(((bar==act_motor)|motor_test_sel_all)?0x44CC44:0x4444DD);  
1022
                            g.fillRect(canvas_width/(8*2)+bar*2*canvas_width/8,y_off+10,canvas_width/8,y_off+20+motor_test[bar]);
1023
                            g.setColor(0x000000);
1024
                            g.drawString(""+motor_test[bar] ,canvas_width/8+bar*2*canvas_width/8,y_off+10,Graphics.TOP | Graphics.HCENTER);
1025
                            g.drawString(""+mk.debug_data.motor_val(bar) ,canvas_width/8+bar*2*canvas_width/8,y_off+25,Graphics.TOP | Graphics.HCENTER);
1026
                        }
1027
                    break;
1028
 
1029
                case STATEID_EDIT_PARAMS:
1030
                    params_editor.paint(g);
1031
                    break;
1032
 
1033
                case STATEID_SELECT_COMPORT:
1034
                    g.drawString("ports: " + System.getProperty("microedition.commports"),0,y_off,Graphics.TOP | Graphics.LEFT);
1035
                    y_off+=spacer;
1036
                    paint_menu(g);
1037
                    break;
1038
 
1039
//#if fileapi=="on"
1040
                case STATEID_FILEOPEN:
1041
                    y_off+=spacer;
1042
                    g.drawString("act_path" + act_path() ,0,y_off,Graphics.TOP | Graphics.LEFT);
1043
                    paint_menu(g);
1044
                    break;
1045
//#endif
213 ligi 1046
                case STATEID_STRINGINPUT:
206 ligi 1047
                case STATEID_ABOUT:
1048
                case STATEID_IPINPUT:
1049
                    paint_lcd(g,true);
1050
                    break;
1051
 
1052
                case STATEID_READ_PARAMS:
1053
                    paint_lcd(g,true);
1054
                    break;
1055
 
1056
 
1057
//#if bluetooth=="on"
1058
                case STATEID_SCANNING:
1059
                    paint_lcd(g,true);
1060
                    break;
1061
//#endif
1062
                case STATEID_RAWDEBUG: 
1063
                    g.setFont(f2);
1064
                    rawdebug_off_y=0;
1065
                    if ((rawdebug_cursor_y+3)*spacer1>canvas_height)
1066
                        rawdebug_off_y=((rawdebug_cursor_y+3)*spacer1-canvas_height)/spacer1;
1067
                    for (int i=0;i<(canvas_height/spacer1)-1;i++)
1068
                        {
1069
                            if (i+rawdebug_off_y==rawdebug_cursor_y)
1070
                                {
1071
                                g.setColor(0x0000CC);
1072
                                g.fillRect(0,y_off,canvas_width,spacer1);
1073
 
1074
                                g.setColor(skin_fg_color());
1075
 
1076
 
1077
                                }
1078
                            if (i+rawdebug_off_y<32) //todo better style
1079
                                g.drawString(mk.debug_data.names[i+rawdebug_off_y] + mk.debug_data.analog[i+rawdebug_off_y] ,0,y_off,Graphics.TOP | Graphics.LEFT);
1080
 
1081
                            y_off+=spacer1;
1082
 
1083
                        }
1084
 
1085
 
1086
 
1087
                    break;
1088
 
1089
 
1090
                case STATEID_CONN_DETAILS:     
1091
                    g.setFont(f1);
1092
                    g.drawString("Connection::",0,y_off,Graphics.TOP | Graphics.LEFT);
1093
                    y_off+=spacer;
1094
                    g.setFont(f2);
1095
 
1096
                    g.drawString(" URL:" + mk.mk_url,0,y_off,Graphics.TOP | Graphics.LEFT);
1097
                    y_off+=spacer1;
1098
 
1099
                    g.drawString(" Name:" + mk.name,0,y_off,Graphics.TOP | Graphics.LEFT);
1100
                    y_off+=spacer1;
1101
 
1102
                    g.drawString(" "+mk.ufo_prober.extended_name()+ " (" + (mk.connected?("open"+((System.currentTimeMillis()- mk.connection_start_time)/1000)+"s"):"closed")+"):",0,y_off,Graphics.TOP | Graphics.LEFT);
1103
                    y_off+=spacer1;
1104
                    g.drawString(" Version:" + mk.version.str ,0,y_off,Graphics.TOP | Graphics.LEFT);
1105
                    y_off+=spacer1;
1106
                    g.drawString(" Slave-Addr:" + mk.slave_addr,0,y_off,Graphics.TOP | Graphics.LEFT);
1107
 
1108
                    paint_menu(g);
1109
 
1110
                    break;
1111
 
1112
                case STATEID_TRAFFIC:
1113
 
1114
                    g.setFont(f1);
1115
                    g.drawString("Packet Traffic (over "+mk.conn_time_in_s()+"s):",0,y_off,Graphics.TOP | Graphics.LEFT);
1116
                    y_off+=spacer;
1117
                    g.setFont(f2);
1118
                    g.drawString( ">>in:"+mk.stats.bytes_in+ " bytes => " + mk.stats.bytes_in/mk.conn_time_in_s() + " bytes/s",0,y_off,Graphics.TOP | Graphics.LEFT);
1119
                    y_off+=spacer1;
1120
 
1121
 
1122
 
1123
 
1124
                    g.drawString( " debug:"+mk.stats.debug_data_count+ " LCD:" + mk.stats.lcd_data_count + " vers:" + mk.stats.version_data_count,0,y_off,Graphics.TOP | Graphics.LEFT);
1125
                    y_off+=spacer1;
1126
                    g.drawString( " other:"+mk.stats.other_data_count+" params:"+mk.stats.params_data_count + " GPS:"+mk.stats.navi_data_count ,0,y_off,Graphics.TOP | Graphics.LEFT);
1127
                    y_off+=spacer1;
1128
                    g.drawString( " debug_names:" + mk.stats.debug_names_count + " angles:" + mk.stats.angle_data_count ,0,y_off,Graphics.TOP | Graphics.LEFT);
1129
 
1130
 
1131
                    y_off+=spacer1+3;
1132
                    g.drawString( "<<out:"+mk.stats.bytes_out + " bytes =>" + mk.stats.bytes_out/mk.conn_time_in_s() + "bytes/s", 0,y_off,Graphics.TOP | Graphics.LEFT);
1133
                    y_off+=spacer1;
1134
                    g.drawString( " LCD:" + mk.stats.lcd_data_request_count + " vers:" + mk.stats.version_data_request_count,0,y_off,Graphics.TOP | Graphics.LEFT);
1135
                    y_off+=spacer1;
1136
                    g.drawString( " params:"+mk.stats.params_data_request_count ,0,y_off,Graphics.TOP | Graphics.LEFT);
1137
                    y_off+=spacer1;
1138
 
1139
                    paint_menu(g);
1140
                    break;
1141
 
1142
                case STATEID_PROXY:    
1143
                    g.setFont(f1);
1144
                    g.drawString("Host:",0,y_off,Graphics.TOP | Graphics.LEFT);
1145
                    y_off+=spacer;
1146
                    g.setFont(f2);
1147
                    g.drawString(" " + mk.proxy.url + "("+((mk.proxy.connected)?"open":"closed") +")",0,y_off,Graphics.TOP | Graphics.LEFT);
1148
                    y_off+=spacer1;
1149
 
1150
 
1151
 
1152
                    break;
1153
 
211 ligi 1154
                // falltru wanted
1155
                case STATEID_SELECT_SPEED_FORMAT:
1156
                case STATEID_SELECT_GPS_FORMAT:
206 ligi 1157
                case STATEID_MAINMENU: 
1158
 
1159
                case STATEID_SETTINGSMENU:
211 ligi 1160
 
206 ligi 1161
                case STATEID_SELECT_PARAMSET:
1162
                case STATEID_HANDLE_PARAMS:
1163
 
1164
                case STATEID_DEVICESELECT:
1165
 
1166
                    paint_menu(g);
1167
                    break;
1168
 
1169
 
1170
                case STATEID_GRAPH:
1171
 
1172
                    g.setClip(0,0,canvas_width,canvas_height);
1173
 
1174
                    g.setStrokeStyle(Graphics.DOTTED);  
1175
                    g.setColor(0xe1dddd);
1176
 
1177
                    for (int d=0;d<GRAPH_COUNT;d++)
1178
                        {
1179
                            g.setColor(graph_colors[d]);               
1180
                            g.fillRect(0,y_off +spacer1/2-2 ,20,4);
1181
                            g.setColor(skin_fg_color());
1182
                            g.drawString(graph_names[d],23,y_off,Graphics.TOP | Graphics.LEFT);
1183
                            y_off+=spacer1;
1184
 
1185
                        }
1186
 
1187
                    /*
1188
                    g.drawString("scale:"+scale + "line scaler" + line_scaler,0,y_off,Graphics.TOP | Graphics.LEFT);
1189
 
1190
 
1191
                    int jump=0;
1192
                    g.drawLine(0,line_middle_y,canvas_width,line_middle_y);
1193
 
1194
                    while (jump<canvas_height/2)
1195
                        {
1196
                            g.drawLine(0,line_middle_y - jump/line_scaler,canvas_width,line_middle_y - jump/line_scaler);
1197
                            g.drawLine(0,line_middle_y + jump/line_scaler,canvas_width,line_middle_y + jump/line_scaler);
1198
                            jump+=scale;
1199
                        }
1200
                    */
1201
 
1202
 
1203
 
1204
                    for (int gr=0;gr<GRAPH_COUNT;gr++)
1205
                        {
1206
 
1207
                            g.setColor(graph_colors[gr]);              
1208
                            try {
1209
                                graph_data[gr][-bg_offset]=mk.debug_data.analog[graph_sources[gr]];
1210
                            }
1211
                            catch (Exception e)
1212
                                {
1213
                                    debug.log("E!:" + e.getMessage());
1214
 
1215
                                }
1216
 
1217
 
1218
 
1219
                            for ( int x=0;x<canvas_width;x++)
1220
                                {
1221
                                    int p= (((-bg_offset+x-canvas_width-5)));
1222
                                    if (p<1)
1223
                                        p+=graph_data[0].length;
1224
                                    p%=(graph_data[0].length-1);
1225
 
1226
                                    draw_graph_part(g,x,graph_data[gr][p]/line_scaler,graph_data[gr][p+1]/line_scaler);
1227
 
1228
                                }
1229
                        }
1230
 
1231
                    break;
1232
 
1233
                case STATEID_FLIGHTVIEW:
1234
                    /*
1235
                    g.setClip(canvas_width/2-load_img.getWidth()/6+1,canvas_height/2-load_img.getHeight()/8+1, load_img.getWidth()/4,load_img.getHeight()/3);;
1236
                    if (( mk.LCD.init_state!=-1)||(mk.LCD.act_mk_page!=mk.LCD.act_user_page)) g.drawImage(load_img,canvas_width/2-load_img.getWidth()/8 - ((((frame_pos/3)%12)%4)*(load_img.getWidth()/4)) ,canvas_height/2-load_img.getHeight()/6- ((((frame_pos/3)%12)/4)*(load_img.getHeight()/3)), g.TOP | g.LEFT);            
1237
 
1238
                    */
1239
                    /*
1240
                    // !!TODO!! check exactly which version those Datas where introduced
1241
                    if (mk.version.compare(0,60)==mk.version.VERSION_PREVIOUS)
1242
                        {
1243
                            g.drawString("Voltage: " + (mk.debug_data.UBatt()/10) + "," +(mk.debug_data.UBatt()%10)+"V" ,0,y_off,Graphics.TOP | Graphics.LEFT);
1244
                            g.drawString("Sender: " + mk.debug_data.SenderOkay(),canvas_width/2,y_off,Graphics.TOP | Graphics.LEFT);
1245
                            y_off+=spacer;
1246
                        }
1247
 
1248
                    g.drawString(mk.version.str+"(d"+mk.debug_data_count+ "l" + mk.lcd_data_count+  "v" + mk.version_data_count+"o"+mk.other_data_count+"p"+mk.params_data_count+")",0,y_off,Graphics.TOP | Graphics.LEFT);
1249
 
1250
                    y_off+=spacer;
1251
 
1252
                    g.drawString("n:"+mk.debug_data.nick_int() + " r:"+mk.debug_data.roll_int() + " an:"+mk.debug_data.accnick() + " ar:"+mk.debug_data.accroll() ,0,y_off,Graphics.TOP | Graphics.LEFT);
1253
                    y_off+=spacer;
1254
 
1255
 
1256
                    g.drawString("m1:"+mk.debug_data.motor_val(0) + " m2:"+mk.debug_data.motor_val(1)+" m3:"+mk.debug_data.motor_val(2) + " m4:"+mk.debug_data.motor_val(3) ,0,y_off,Graphics.TOP | Graphics.LEFT);
1257
                    y_off+=spacer;
1258
 
1259
                    if (mk.connected)
1260
                        {
1261
                            g.drawString("time conn:" +((System.currentTimeMillis()- mk.connection_start_time)/1000)+"s" ,0,y_off,Graphics.TOP | Graphics.LEFT);
1262
                            y_off+=spacer;
1263
                            g.drawString("time motor>15:" +(mk_stat.motor_on_time/1000) +"s" ,0,y_off,Graphics.TOP | Graphics.LEFT);
1264
                            y_off+=spacer;
1265
                            g.drawString("time motor=15:" +(mk_stat.motor_stand_time/1000) +"s" ,0,y_off,Graphics.TOP | Graphics.LEFT);
1266
                            y_off+=spacer;
1267
                            g.drawString("lcd:" + mk.LCD.act_mk_page + "/" + mk.LCD.pages + " ( wanted: " + mk.LCD.act_user_page + "state:" + mk.LCD.init_state +")" ,0,y_off,Graphics.TOP | Graphics.LEFT);
1268
 
1269
                            y_off+=spacer;
1270
                            g.drawString("lcd-key:" + mk.LCD.act_key ,0,y_off,Graphics.TOP | Graphics.LEFT);
1271
 
1272
                        }
1273
*/
1274
 
1275
                    int spacer_left_right=(canvas_width-(20*(lcd_img.getWidth()/222)))/2;
1276
 
1277
                    y_off=canvas_height-4*lcd_img.getHeight();
1278
 
1279
                    for ( int foo=0;foo<4;foo++)
1280
                        {
1281
                            for (int x=0;x<20;x++)
1282
                                {
1283
                                    g.setClip(spacer_left_right+(lcd_img.getWidth()/222)*x,y_off,(lcd_img.getWidth()/222),lcd_img.getHeight());
1284
                                            g.drawImage(lcd_img,spacer_left_right+(lcd_img.getWidth()/222)*x-(mk.LCD.get_act_page()[foo].charAt(x)-' ')*(lcd_img.getWidth()/222),y_off, g.TOP | g.LEFT);
1285
 
1286
                                        }
1287
                                    y_off+=lcd_img.getHeight();
1288
                                }
1289
 
1290
                    g.setClip(0,0,canvas_width,canvas_height);
1291
 
1292
                }
1293
 
1294
 
1295
 
1296
        } catch (Exception e) {}
1297
 
1298
    }
1299
    Player mPlayer;
1300
    VideoControl        mVideoControl;
1301
    Image cam_img;
1302
    int cam_img_seq=0;
1303
    byte[] cam_raw;
1304
 
1305
    private void connect_mk(String url,String name)
1306
    {
1307
        //      mk.ufo_prober.bluetooth_probe(url);
1308
        settings.connection_url=url;
1309
        settings.connection_name=name;
1310
        mk.connect_to(url,name);
1311
    }
1312
 
1313
    public void draw_graph_part(Graphics g,int x,int y1,int y2)
1314
    {
1315
        if ( canvas_width>200)
1316
            {
1317
                g.fillRect(x,line_middle_y-y1,1,1 );
1318
                if (y1>y2)
1319
                    g.fillRect(x,line_middle_y-y1,1,y1-y2);
1320
                else
1321
                    g.fillRect(x,line_middle_y-y2,1,y2-y1);
1322
 
1323
            }
1324
        else
1325
            {
1326
            g.fillRect(x,line_middle_y-y1,1,1 );
1327
                if (y1>y2)
1328
                    g.fillRect(x,line_middle_y-y1,1,y1-y2);
1329
                else
1330
                    g.fillRect(x,line_middle_y-y2,1,y2-y1);
1331
            }
1332
 
1333
    }
1334
 
1335
 
1336
    /*********************************************** input Section **********************************************/
1337
 
1338
 
1339
 
1340
    //    public final String intro_str="   Digital Ufo Broadcasting with intelligent service equipment by Marcus -LiGi- Bueschleb ; Big Up Holger&Ingo for the MikroKopter Project (http://www.mikrokopter.de) ";
1341
 
1342
    //    int intro_str_pos=0;
1343
    // int intro_str_delay=3;
1344
    boolean init_bootloader=false;
1345
 
1346
    public void chg_state(byte next_state)
1347
    {
1348
        if (next_state!=state)act_menu_select=0;
1349
        // prepare next state
1350
        switch(next_state)
1351
            {
213 ligi 1352
            case STATEID_STRINGINPUT:
1353
                lcd_lines=new String[2];
1354
                lcd_lines[0]=act_input_str;
1355
                lcd_lines[1]="^";
1356
 
1357
                break;
206 ligi 1358
            case STATEID_FLIGHTVIEW:
1359
                mk.user_intent=USER_INTENT_LCD;
1360
                break;
1361
            case STATEID_FLASHING:
1362
                mk.bootloader_intension_flash=true;
1363
                init_bootloader=true;
1364
                break;
1365
 
1366
 //#if fileapi=="on"
1367
            case STATEID_FILEOPEN:
1368
                if (act_path_depth==0)
1369
                    {
1370
                        Enumeration drives = FileSystemRegistry.listRoots();
1371
                        int tmp_i=0;
1372
                        while(drives.hasMoreElements())
1373
                            {  
1374
                                file_list[tmp_i]= (String) drives.nextElement();
1375
                                tmp_i++;
1376
 
1377
                                if (MAX_FILELIST_LENGTH<tmp_i)
1378
                                    break;
1379
                            }                  
1380
                        menu_items=new String[tmp_i];
1381
                        lcd_lines=new String[tmp_i];
1382
                        file_list_length=tmp_i;
1383
 
1384
                        for(tmp_i=0;tmp_i<file_list_length;tmp_i++)
1385
                            menu_items[tmp_i]=file_list[tmp_i];
1386
 
1387
                    }
1388
                else
1389
                    {
1390
 
1391
                        try {
1392
                            FileConnection fc = (FileConnection) Connector.open("file:///"+act_path());
1393
                            Enumeration filelist = fc.list("*", true);
1394
                            int tmp_i=0;
1395
                            while(filelist.hasMoreElements()) {
1396
                                file_list[tmp_i] = (String) filelist.nextElement();
1397
                                tmp_i++;
1398
                                /*                              fc = (FileConnection)
1399
                                    Connector.open("file:///CFCard/" + fileName);
1400
                                if(fc.isDirectory()) {
1401
                                    System.out.println("\tDirectory Name: " + fileName);
1402
                                } else {
1403
                                    System.out.println
1404
                                        ("\tFile Name: " + fileName +
1405
                                         "\tSize: "+fc.fileSize());
1406
                                         }*/
1407
 
1408
                            }  
1409
 
1410
                            menu_items=new String[tmp_i+1];
1411
                            lcd_lines=new String[tmp_i+1];
1412
                            file_list_length=tmp_i+1;
1413
 
1414
                            menu_items[0]="..";
1415
                            for(tmp_i=1;tmp_i<file_list_length;tmp_i++)
1416
                                menu_items[tmp_i]=file_list[tmp_i-1];
1417
 
1418
 
1419
                            fc.close();
1420
                        } catch (IOException ioe) {
1421
                            System.out.println(ioe.getMessage());
1422
                        }
1423
                    }
1424
 
1425
 
1426
                break;
1427
//#endif
1428
 
1429
            case STATEID_STICKVIEW:
1430
                mk.user_intent=USER_INTENT_RCDATA;
1431
                break;
1432
            case STATEID_SELECT_COMPORT:       
1433
                menu_items=new String[6];
1434
                lcd_lines=new String[6];
1435
 
1436
                menu_items[0]="com0";
1437
                menu_items[1]="com1";
1438
                menu_items[2]="com2";
1439
                menu_items[3]="com3";
1440
                menu_items[4]="com4";
1441
 
1442
                menu_items[5]="back";
1443
                break;
1444
 
1445
 
1446
            case STATEID_NC_ERRORS:
1447
                lcd_lines=new String[1];
1448
                lcd_lines[0]=""+mk.error_str;
1449
                break;
1450
 
1451
            case STATEID_ABOUT:
1452
                lcd_lines=credits;
213 ligi 1453
                lcd_lines[1]=" ufo-lib: " + mk.lib_version_str();
206 ligi 1454
                act_menu_select=max_lines-1;
1455
                break;
1456
            case STATEID_CONN_DETAILS: 
1457
                setup_menu(conn_details_menu_items,conn_details_menu_actions);
1458
                break;
1459
 
211 ligi 1460
            case STATEID_SELECT_GPS_FORMAT:    
1461
                setup_menu(set_gps_format_menu_items,set_gps_format_menu_actions);
1462
 
1463
                break;
1464
 
1465
 
1466
            case STATEID_SELECT_SPEED_FORMAT:  
1467
                setup_menu(set_speed_format_menu_items,set_speed_format_menu_actions);
1468
 
1469
                break;
1470
 
206 ligi 1471
            case STATEID_TRAFFIC:      
1472
                setup_menu(onlyback_menu_items,back_to_conndetails_actions);
1473
                break;
1474
            case STATEID_CAMMODE:
1475
 
1476
                if (mVideoControl==null)
1477
                    try
1478
                        {
1479
                            debug.log("creating player\n");
1480
                            mPlayer = Manager.createPlayer("capture://video?encoding=png&width=2048&height=1536");
1481
 
1482
                            debug.log("realizing player\n");
1483
                            mPlayer.realize();
1484
 
1485
                            debug.log("get_videocontrol\n");
1486
 
1487
                            mVideoControl = (VideoControl)mPlayer.getControl("VideoControl");
1488
 
1489
                            debug.log("switching Canvas\n");
1490
                            mVideoControl.initDisplayMode(VideoControl.USE_DIRECT_VIDEO, this);
1491
 
1492
                            debug.log("get snap\n");
1493
                            byte[] raw = mVideoControl.getSnapshot(null);    
1494
 
1495
                        }
1496
                    catch ( Exception e)
1497
                        {
1498
                            debug.log(e.toString());
1499
                        }
1500
 
1501
 
1502
                break;
1503
            case STATEID_KEYCONTROL:
1504
                keycontrol_exit=0;
1505
                break;
1506
 
1507
            case STATEID_READ_PARAMS:
1508
                mk.user_intent=USER_INTENT_PARAMS;
1509
                lcd_lines=new String[2];
1510
                lcd_lines[0]="Reading Settings    ";
1511
                lcd_lines[1]=mk.watchdog.act_paramset+"/5 |"+ (mk.watchdog.act_paramset>0?"#":"_") + (mk.watchdog.act_paramset>1?"#":"_") + (mk.watchdog.act_paramset>2?"#":"_")+ (mk.watchdog.act_paramset>3?"#":"_")+ (mk.watchdog.act_paramset>4?"#":"_") + "|         ";
1512
 
1513
                break;
1514
 
1515
            case STATEID_IPINPUT:
1516
 
1517
                lcd_lines=new String[3];
1518
                lcd_lines[0]="Address (IP:Port):  ";
1519
                break;
1520
 
1521
//#if bluetooth=="on"
1522
            case STATEID_SCANNING:
1523
                lcd_lines=new String[3];
1524
                lcd_lines[0]="Searching for";
1525
                lcd_lines[1]="Bluetooth Devices";
1526
                lcd_lines[2]="found";
1527
 
1528
                mk.close_connections(true);
1529
                bt_scanner.search();
1530
                break;
1531
//#endif
1532
 
1533
            case STATEID_HANDLE_PARAMS:
1534
                menu_items=handle_params_menu_items;
1535
                menu_actions=handle_params_menu_actions;
1536
                lcd_lines=new String[menu_items.length];
1537
 
1538
                break;
1539
 
1540
            case STATEID_SELECT_PARAMSET:
1541
                menu_items=new String[5];
1542
                for (int i=0;i<5;i++)
213 ligi 1543
                    menu_items[i]=""+i+": " + mk.params.names[i] + ((i==mk.params.active_paramset)?"*":"");
206 ligi 1544
 
1545
                lcd_lines=new String[5];
1546
                break;
1547
 
1548
//#if bluetooth=="on"
1549
            case STATEID_DEVICESELECT:
1550
 
1551
                menu_items=new String[bt_scanner.remote_device_count+2];
1552
                lcd_lines=new String[bt_scanner.remote_device_count+2];
1553
 
1554
                for (int i=0;i<bt_scanner.remote_device_count;i++)
1555
                    menu_items[i]=bt_scanner.remote_device_name[i];
1556
                menu_items[bt_scanner.remote_device_count]="scan again";
1557
                menu_items[bt_scanner.remote_device_count+1]="cancel";
1558
 
1559
                break;
1560
//#endif
1561
 
1562
            case STATEID_MAINMENU:
214 ligi 1563
                setup_main_menu();
1564
 
206 ligi 1565
                break;
1566
 
1567
            case STATEID_SETTINGSMENU:
1568
 
1569
                menu_items=new String[settings_menu_items.length];
1570
                for(int cnt=0;cnt<settings_menu_items.length;cnt++)
1571
                    menu_items[cnt]=settings_menu_items[cnt];
1572
 
1573
                menu_items[0]+=(settings.act_skin==SKINID_DARK)?"Dark":"Light";
1574
                menu_items[1]+=(!settings.do_sound)?"Off":"On";
1575
                menu_items[2]+=(!settings.do_vibra)?"Off":"On";
1576
                menu_items[3]+=(!settings.do_scrollbg)?"Off":"On";
1577
                menu_items[4]+=(!settings.fullscreen)?"Off":"On";
211 ligi 1578
                menu_items[5]+=(mk.gps_position.act_gps_format==0)?" Decimal":" MinSec";
1579
                menu_items[6]+=(mk.gps_position.act_speed_format==0)?" KM/H":((mk.gps_position.act_speed_format==1)?" MP/H":"CM/S");
206 ligi 1580
 
1581
//#if devicecontrol=="on"
211 ligi 1582
                menu_items[7]+=(!settings.keep_lighton)?"Off":"On";
206 ligi 1583
//#endif
214 ligi 1584
                menu_items[8]+=(!settings.expert_mode)?" Off":" On";
206 ligi 1585
                menu_actions=settings_menu_actions;
1586
                lcd_lines=new String[menu_items.length];
1587
                break;
1588
 
1589
            case STATEID_RAWDEBUG:
1590
                mk.user_intent=USER_INTENT_RAWDEBUG;
1591
                break;
1592
 
1593
 
1594
            case STATEID_GRAPH:
1595
                mk.user_intent=USER_INTENT_GRAPH;
1596
                break;
1597
 
1598
            }
1599
        mk.watchdog.resend_timeout=0;
1600
 
1601
        // switch state
1602
        state=next_state;
1603
    } // void chg_state
1604
 
1605
 
1606
    public void keyReleased(int keyCode)
1607
    {
1608
 
1609
        switch(state)
1610
            {
1611
            case STATEID_MOTORTEST:
1612
                act_motor_increase=0;
1613
                break;
1614
 
1615
            case STATEID_KEYCONTROL:
1616
                if (keyCode==KEY_POUND)
1617
                    keycontrol_exit &= 255^1;
1618
                else
1619
                if (keyCode==KEY_STAR)
1620
                    keycontrol_exit &= 255^2;
1621
                else
1622
                if ((keyCode >= this.KEY_NUM0) && (keyCode < this.KEY_NUM8))
1623
                    keycontrol_bitfield[0]&=255^( 1<<(keyCode-this.KEY_NUM0));
1624
                else
1625
                    if ((keyCode >= this.KEY_NUM8) && (keyCode <= this.KEY_NUM9))
1626
                        keycontrol_bitfield[1]&=255^( 1<<(keyCode-this.KEY_NUM8));
1627
                else
1628
                    switch (getGameAction (keyCode))
1629
                            {
1630
                            case UP:
1631
                                keycontrol_bitfield[1]&=255^4;
1632
                                break;
1633
 
1634
                            case DOWN:
1635
                                keycontrol_bitfield[1]&=255^8;
1636
                                break;
1637
 
1638
 
1639
                            case LEFT:
1640
                                keycontrol_bitfield[1]&=255^16;
1641
                                break;
1642
 
1643
                            case RIGHT:
1644
                                keycontrol_bitfield[1]&=255^32;
1645
                                break;
1646
 
1647
                            case FIRE:
1648
                                keycontrol_bitfield[1]&=255^64;
1649
                                break;
1650
 
1651
 
1652
                            }
1653
                mk.send_keys(keycontrol_bitfield);
1654
                break;
1655
            }
1656
 
1657
    }
1658
 
1659
 
1660
    byte keycontrol_exit=0;
1661
 
1662
    public final static int[] keycontrol_bitfield={0,0};
1663
 
1664
 
1665
    public void pointerPressed (int pointer_x, int pointer_y)
1666
    {
1667
        if (pointer_y<lcd_img.getHeight())
1668
            keyPressed(KEY_STAR);
1669
        else
1670
            switch(state)
1671
                {
1672
                case STATEID_CONN_DETAILS:
1673
                case STATEID_SETTINGSMENU:
1674
                case STATEID_FILEOPEN:
1675
                case STATEID_TRAFFIC:
1676
                case STATEID_SELECT_COMPORT:   
1677
                case STATEID_MAINMENU:
1678
                case STATEID_SELECT_PARAMSET:
1679
                case STATEID_DEVICESELECT:
1680
 
1681
                    if (pointer_y>canvas_height-lcd_img.getHeight()*menu_items.length)
1682
                        {                      
1683
                            act_menu_select=(pointer_y-(canvas_height-lcd_img.getHeight()*menu_items.length))/lcd_img.getHeight();
1684
                            keyPressed(getKeyCode(FIRE));
1685
                        }    
1686
                    break;
1687
                }
1688
    }
213 ligi 1689
 
1690
 
1691
    int last_keycode=-1;
1692
    int repeat_keycode=0;
1693
 
206 ligi 1694
    public void keyPressed(int keyCode)
1695
    {
213 ligi 1696
        if (last_keycode==keyCode)
1697
            repeat_keycode++;
1698
        else
1699
            {
1700
                repeat_keycode=0;
1701
                last_keycode=keyCode;
1702
            }
1703
 
206 ligi 1704
        debug.log("KeyCode:"+keyCode);
1705
        // key-actions common in all states
1706
        debug.process_key(keyCode);
1707
 
213 ligi 1708
 
206 ligi 1709
        if ((keyCode==KEY_NUM9))
213 ligi 1710
            { chg_state(STATEID_STRINGINPUT); }
206 ligi 1711
 
1712
 
213 ligi 1713
 
206 ligi 1714
 
1715
 
213 ligi 1716
 
1717
        if (((keyCode==KEY_STAR) || (keyCode==113) ))//&&(state!= STATEID_STRINGINPUT))
206 ligi 1718
            {
1719
                if (state==STATEID_EDIT_PARAMS)
1720
                    {
1721
                        chg_state(STATEID_HANDLE_PARAMS);
1722
                        return;
1723
                    }
1724
                else
1725
                    if (state!=STATEID_KEYCONTROL)
1726
                        {
1727
                        chg_state(STATEID_MAINMENU);
1728
                        return;
1729
                        }
1730
 
1731
            }
213 ligi 1732
 
1733
 
206 ligi 1734
        if ((keyCode==KEY_POUND)&&(state!=STATEID_KEYCONTROL))
1735
            {
1736
                settings.fullscreen=!settings.fullscreen;
1737
                setFullScreenMode(settings.fullscreen);
1738
                return;
1739
            }
1740
 
1741
        // key actions per state
1742
        switch(state)
1743
            {
1744
 
1745
            case STATEID_NC_ERRORS:
1746
                chg_state(STATEID_MAINMENU);
1747
                break;
213 ligi 1748
            case STATEID_STRINGINPUT:
1749
                if ((keyCode>=KEY_NUM2)&&(keyCode<=KEY_NUM9))
1750
                    {
1751
                        act_input_str=act_input_str.substring(0,ipinput_pos) +
1752
 
1753
 
1754
                            (char)( 97 + (keyCode-KEY_NUM2)*3 + ((keyCode>KEY_NUM7)?1:0) +(repeat_keycode%(((keyCode==KEY_NUM7)||(keyCode==KEY_NUM9))?4:3)))
1755
 
1756
                            + act_input_str.substring(ipinput_pos+1,act_input_str.length());
1757
                    }
1758
                else if ((keyCode==KEY_NUM0))
1759
                    {
1760
                        act_input_str=act_input_str.substring(0,ipinput_pos) +
1761
                            act_input_str.substring(ipinput_pos+1,act_input_str.length());
1762
                    }
1763
                else
1764
                    {
1765
                    switch (getGameAction (keyCode))
1766
                        {
1767
 
1768
                        case LEFT:
1769
                            if(ipinput_pos>0) ipinput_pos--;
1770
                            break;
1771
 
1772
                        case RIGHT:
1773
                            if(ipinput_pos<19)  ipinput_pos++;
1774
                            break;
1775
 
1776
                        case UP:
1777
                            act_input_str=act_input_str.substring(0,ipinput_pos) +
1778
                                (char)((byte) act_input_str.charAt(ipinput_pos)-1) + act_input_str.substring(ipinput_pos+1,act_input_str.length());
1779
 
1780
                            break;
1781
                        case DOWN:
1782
                            act_input_str=act_input_str.substring(0,ipinput_pos) +
1783
                                (char)((byte) act_input_str.charAt(ipinput_pos)+1) + act_input_str.substring(ipinput_pos+1,act_input_str.length());
1784
 
1785
                            break;
1786
 
1787
 
1788
                        case FIRE:
1789
                            mk.params.set_name(act_input_str);
1790
                            chg_state(STATEID_HANDLE_PARAMS);
1791
                            break;
1792
                        }
1793
 
1794
                    }
1795
                if (act_input_str.length()<=ipinput_pos) act_input_str+=" ";
1796
                break;
206 ligi 1797
            case STATEID_IPINPUT:
1798
                if ((keyCode>=KEY_NUM0)&&(keyCode<=KEY_NUM9))
1799
                    {
1800
                        act_edit_ip[ipinput_pos/4]=helper.mod_decimal(act_edit_ip[ipinput_pos/4],(ipinput_pos<15?2:3)-(ipinput_pos%4),0,(keyCode-KEY_NUM0),9);
1801
 
1802
                        if(ipinput_pos<19)      ipinput_pos++;
1803
                        if ((ipinput_pos<18)&&(((ipinput_pos+1)%4)==0))ipinput_pos++;
1804
                    }
1805
                else
1806
                    switch (getGameAction (keyCode))
1807
                            {
1808
                            case LEFT:
1809
                                if(ipinput_pos>0) ipinput_pos--;
1810
                                if (((ipinput_pos+1)%4)==0)ipinput_pos--;
1811
                                break;
1812
 
1813
                            case RIGHT:
1814
                                if(ipinput_pos<19)      ipinput_pos++;
1815
                                if(ipinput_pos<18)if (((ipinput_pos+1)%4)==0)ipinput_pos++;
1816
                                break;
1817
 
1818
                            case UP:
1819
                                act_edit_ip[ipinput_pos/4]=helper.mod_decimal(act_edit_ip[ipinput_pos/4],(ipinput_pos<15?2:3)-(ipinput_pos%4),1,-1,9);
1820
 
1821
                                break;
1822
 
1823
                            case DOWN:
1824
                                act_edit_ip[ipinput_pos/4]=helper.mod_decimal(act_edit_ip[ipinput_pos/4],(ipinput_pos<15?2:3)-(ipinput_pos%4),-1,-1,9);
1825
 
1826
 
1827
                            case FIRE:
1828
                                if (ipinput4proxy)
1829
                                    {
1830
                                        settings.act_proxy_ip=act_edit_ip;
1831
                                        mk.do_proxy("socket://"+helper.ip_str(settings.act_proxy_ip,false));
1832
                                        chg_state(STATEID_PROXY);
1833
                                    }
1834
                                else
1835
                                    {
1836
                                        settings.act_conn_ip=act_edit_ip;
1837
                                        connect_mk("socket://"+helper.ip_str(settings.act_conn_ip,false),"TCP/IP Connection");
1838
                                        chg_state(STATEID_CONN_DETAILS);
1839
                                    }
1840
 
1841
                                break;
1842
 
1843
                            }
1844
                break;
1845
 
1846
            case STATEID_GPSVIEW:
1847
                if (keyCode == this.KEY_NUM0)
1848
                    mk.set_gps_target(mk.gps_position.Latitude,mk.gps_position.Longitude);
1849
 
1850
 
1851
 
1852
                if (keyCode == this.KEY_NUM1)
1853
                    mk.gps_position.push_wp();
1854
                if (keyCode == this.KEY_NUM2)
1855
                    chg_state(STATEID_FILEOPEN);
1856
                if (keyCode == this.KEY_NUM3)
1857
                    mk.set_gps_target(mk.gps_position.LatWP[act_wp],mk.gps_position.LongWP[act_wp]);
1858
 
1859
 
1860
                if (keyCode == this.KEY_NUM5)
1861
                    heading_offset= mk.debug_data.analog[26];
1862
 
1863
                switch (getGameAction (keyCode))
1864
                            {
1865
                            case UP:
1866
                                if (act_wp!=0) act_wp--;
1867
                                break;
1868
 
1869
                            case DOWN:
1870
                                if (act_wp<mk.gps_position.last_wp) act_wp++;
1871
 
1872
                                break;
1873
 
1874
 
1875
                            }
1876
 
1877
 
1878
                break;
1879
 
1880
            case STATEID_ABOUT:
1881
 
1882
                switch (getGameAction (keyCode))
1883
                            {
1884
                            case UP:
1885
                                if (act_menu_select>=max_lines)
1886
                                    act_menu_select--;
1887
                                break;
1888
 
1889
                            case DOWN:
1890
                                if (act_menu_select<lcd_lines.length-1)
1891
                                    act_menu_select++;
1892
 
1893
                                break;
1894
 
1895
 
1896
                            }
1897
 
1898
 
1899
                break;
1900
 
1901
 
1902
            case STATEID_RAWDEBUG:
1903
 
1904
                switch (getGameAction (keyCode))
1905
                            {
1906
                            case UP:
1907
                                if (rawdebug_cursor_y==0)
1908
                                    rawdebug_cursor_y=31;
1909
                                else
1910
                                    rawdebug_cursor_y--;
1911
                                break;
1912
 
1913
                            case DOWN:
1914
                                if (rawdebug_cursor_y==31)
1915
                                    rawdebug_cursor_y=0;
1916
                                else
1917
                                    rawdebug_cursor_y++;
1918
                                break;
1919
 
1920
 
1921
                            }
1922
                break;
1923
            case STATEID_KEYCONTROL:
1924
                if (keyCode==KEY_POUND)
1925
                    keycontrol_exit |= 1;
1926
                else
1927
                if (keyCode==KEY_STAR)
1928
                    keycontrol_exit |= 2;
1929
                else
1930
                if ((keyCode >= this.KEY_NUM0) && (keyCode < this.KEY_NUM8))
1931
                    keycontrol_bitfield[0]|=1<<(keyCode-this.KEY_NUM0);
1932
                else
1933
                if ((keyCode >= this.KEY_NUM8) && (keyCode <= this.KEY_NUM9))
1934
                    keycontrol_bitfield[1]|=1<<(keyCode-this.KEY_NUM8);
1935
 
1936
                else
1937
                    switch (getGameAction (keyCode))
1938
                            {
1939
                            case UP:
1940
                                keycontrol_bitfield[1]|=4;
1941
                                break;
1942
 
1943
                            case DOWN:
1944
                                keycontrol_bitfield[1]|=8;
1945
                                break;
1946
 
1947
 
1948
                            case LEFT:
1949
                                keycontrol_bitfield[1]|=16;
1950
                                break;
1951
 
1952
                            case RIGHT:
1953
                                keycontrol_bitfield[1]|=32;
1954
                                break;
1955
 
1956
                            case FIRE:
1957
                                keycontrol_bitfield[1]|=64;
1958
                                break;
1959
 
1960
                            }
1961
                if (keycontrol_exit==3)
1962
                    chg_state(STATEID_MAINMENU);
1963
                else
1964
                    mk.send_keys(keycontrol_bitfield);
1965
                break;
1966
 
1967
 
1968
            case STATEID_MOTORTEST:
1969
                switch (getGameAction (keyCode))
1970
                            {
1971
                            case UP:
1972
                                act_motor_increase=-1;
1973
                                break;
1974
 
1975
                            case DOWN:
1976
                                act_motor_increase=1;
1977
                                break;
1978
 
1979
                            case FIRE:
1980
                                motor_test_sel_all=!motor_test_sel_all;
1981
                                break;
1982
 
1983
                            case LEFT:
1984
                                act_motor--;
1985
                                if (act_motor<0) {act_motor=0; chg_state(STATEID_MAINMENU); }
1986
                                break;
1987
 
1988
                            case RIGHT:
1989
                                act_motor++;
1990
                                act_motor%=4;
1991
                                break;
1992
                            }
1993
 
1994
                break;
1995
 
1996
            case STATEID_SELECT_COMPORT:       
1997
                if ( getGameAction (keyCode)==FIRE )
1998
                    {
1999
 
2000
                        if (act_menu_select<menu_items.length)
2001
                            connect_mk("comm:com"+act_menu_select+";baudrate=57600","com"+act_menu_select);
2002
 
2003
                        chg_state(STATEID_CONN_DETAILS);                           
2004
                    }
2005
                else
2006
                    menu_keypress(keyCode);
2007
                break;
2008
 
2009
                /*
2010
            case STATEID_HANDLsE_PARAMS:
2011
 
2012
                menu_keypress(keyCode);
2013
                break;
2014
                */
2015
                /*
2016
            case STATEID_TRAFFIC:
2017
                if ( getGameAction (keyCode)==FIRE )
2018
                    chg_state(STATEID_CONN_DETAILS);
2019
                else
2020
                    menu_keypress(keyCode);
2021
                break;
2022
                */
2023
//#if fileapi=="on"
2024
            case STATEID_FILEOPEN:
2025
                if ( getGameAction (keyCode)==FIRE )
2026
                    {
2027
                        if ((act_menu_select==0)&&(act_path_depth!=0))
2028
                            {
2029
                                act_path_depth--;
2030
                                //act_path=act_path.substring(0,act_path.substring(0,act_path.length()-2).indexOf('/') );
2031
 
2032
                                //act_path=last_path;
2033
                            }
2034
                        else
2035
                            {
2036
                                //last_path=act_path;
2037
                                if (act_path_depth==0)
2038
                                    act_path_arr[act_path_depth++]=file_list[act_menu_select];
2039
                                else
2040
                                    act_path_arr[act_path_depth++]=file_list[act_menu_select-1];
2041
                            }
2042
                        act_menu_select=0;
2043
                        chg_state(STATEID_FILEOPEN);
2044
 
2045
                    }
2046
                else
2047
                    menu_keypress(keyCode);
2048
                break;
2049
 
2050
//#endif
2051
 
2052
 
2053
                // handle menue
211 ligi 2054
            case STATEID_SELECT_SPEED_FORMAT:  
2055
            case STATEID_SELECT_GPS_FORMAT:
206 ligi 2056
            case STATEID_TRAFFIC:
2057
            case STATEID_CONN_DETAILS:
2058
            case STATEID_HANDLE_PARAMS:
2059
            case STATEID_SETTINGSMENU:
2060
            case STATEID_MAINMENU:
2061
 
2062
                if ( getGameAction (keyCode)==FIRE )
2063
                    {
2064
                        switch(menu_actions[act_menu_select])
2065
                            {
2066
 
214 ligi 2067
                            case ACTIONID_TOGGLE_EXPERT:
2068
                                settings.expert_mode=!settings.expert_mode;
2069
                                chg_state(STATEID_SETTINGSMENU);
2070
                                break;
213 ligi 2071
                            case ACTIONID_RENAME_PARAMS:
2072
                                act_input_str=mk.params.names[mk.params.act_paramset];
2073
                                ipinput_pos=0;
2074
                                chg_state(STATEID_STRINGINPUT);
2075
                                break;
211 ligi 2076
                            case ACTIONID_SET_SPEED_FORMAT_CMS:
2077
                                mk.gps_position.act_speed_format=SPEED_FORMAT_CMS;
2078
                                chg_state(STATEID_SETTINGSMENU);
2079
                                break;
2080
 
2081
                            case ACTIONID_SET_SPEED_FORMAT_MPH:
2082
                                mk.gps_position.act_speed_format=SPEED_FORMAT_MPH;
2083
                                chg_state(STATEID_SETTINGSMENU);
2084
                                break;
2085
 
2086
                            case ACTIONID_SET_SPEED_FORMAT_KMH:
2087
                                mk.gps_position.act_speed_format=SPEED_FORMAT_KMH;
2088
                                chg_state(STATEID_SETTINGSMENU);
2089
                                break;
2090
 
2091
                            case ACTIONID_SELECT_SPEED_FORMAT:
2092
                                chg_state(STATEID_SELECT_SPEED_FORMAT);
2093
                                break;
2094
 
2095
 
2096
                            case ACTIONID_SET_GPS_FORMAT_DECIMAL:
2097
                                mk.gps_position.act_gps_format=GPS_FORMAT_DECIMAL;
2098
                                chg_state(STATEID_SETTINGSMENU);
2099
                                break;
2100
 
2101
                            case ACTIONID_SET_GPS_FORMAT_MINSEC:
2102
                                mk.gps_position.act_gps_format=GPS_FORMAT_MINSEC;
2103
                                chg_state(STATEID_SETTINGSMENU);
2104
                                break;
2105
 
2106
 
2107
                            case ACTIONID_SELECT_GPS_FORMAT:
2108
                                chg_state(STATEID_SELECT_GPS_FORMAT);
2109
                                break;
2110
 
206 ligi 2111
                            case ACTIONID_BACK_TO_CONNDETAILS:
2112
                                chg_state(STATEID_CONN_DETAILS);
2113
                                break;
2114
 
2115
                            case ACTIONID_RESET_PARAMS:
2116
                                state=STATEID_FLASHING;
2117
                                mk.bootloader_intension_flash=false;
2118
                                init_bootloader=true;
2119
                                break;
2120
 
2121
                            case ACTIONID_FLASH:
2122
 
2123
                                chg_state(STATEID_FLASHING);
2124
 
2125
                                //chg_state(STATEID_FLASHING);
2126
                                break;
2127
 
2128
                            case ACTIONID_DATABUFF:
2129
                                chg_state(STATEID_DATABUFF);
2130
                                break;
2131
 
2132
                            case ACTIONID_NC_ERRORS:
2133
                                chg_state(STATEID_NC_ERRORS);
2134
                                break;
2135
 
2136
                            case ACTIONID_ABOUT:
2137
                                chg_state(STATEID_ABOUT);
2138
                                break;
2139
 
2140
                            case ACTIONID_CONN_DETAILS:
2141
                                chg_state(STATEID_CONN_DETAILS);
2142
                                break;
2143
 
2144
                            case ACTIONID_QUIT:
2145
                                quit=true;
2146
                                break;
2147
 
2148
                            case ACTIONID_SWITCH_NC:
2149
                                  mk.switch_to_navi();
2150
                                  break;
2151
 
2152
                            case ACTIONID_SWITCH_FC:
2153
                                  mk.switch_to_fc();
2154
                                  break;
2155
 
2156
                            case ACTIONID_SWITCH_MK3MAG:
2157
                                  mk.switch_to_mk3mag();
2158
                                  break;
2159
 
2160
                            case ACTIONID_GRAPH:
2161
                                chg_state(STATEID_GRAPH);
2162
                                break;
2163
 
2164
                            case ACTIONID_KEYCONTROL:
2165
                                chg_state(STATEID_KEYCONTROL);
2166
                                break;
2167
 
2168
                            case ACTIONID_LCD :
2169
                                chg_state(STATEID_FLIGHTVIEW);
2170
                                break;
2171
 
2172
 
2173
                            case ACTIONID_PROXY:
2174
 
2175
                                chg_state(STATEID_IPINPUT);
2176
                                break;
2177
 
2178
                            case ACTIONID_DEVICESELECT:
2179
                                chg_state(STATEID_SCANNING);
2180
                                break;
2181
 
2182
                            case ACTIONID_RAWDEBUG:
2183
                                chg_state(STATEID_RAWDEBUG);
2184
                                break;
2185
 
2186
                            case ACTIONID_SETTINGS:
2187
                                chg_state(STATEID_SETTINGSMENU);
2188
                                break;
2189
 
2190
                            case ACTIONID_RCDATA:
2191
                                chg_state(STATEID_STICKVIEW);
2192
                                break;
2193
 
2194
                            case ACTIONID_CAM:
2195
                                chg_state(STATEID_CAMMODE);
2196
                                break;
2197
 
2198
                            case ACTIONID_GPSDATA:
2199
                                chg_state(STATEID_GPSVIEW);
2200
                                break;
2201
 
2202
 
2203
                            case  ACTIONID_MOTORTEST :
2204
                                chg_state(STATEID_MOTORTEST);
2205
                                break;
2206
 
2207
 
2208
                            case ACTIONID_EDIT_PARAMS:
2209
                                if (mk.watchdog.act_paramset<5)
2210
                                    chg_state(STATEID_READ_PARAMS);
2211
                                else
2212
                                    chg_state(STATEID_SELECT_PARAMSET);
2213
 
2214
                                break;
2215
 
2216
                            case ACTIONID_CHANGESKIN:
2217
                                settings.act_skin++;
2218
                                settings.act_skin=(byte)(settings.act_skin%2);
2219
                                load_images();
2220
                                chg_state(STATEID_SETTINGSMENU);
2221
                                break;
2222
                            case ACTIONID_SOUNDTOGGLE:
2223
                                settings.do_sound=!settings.do_sound;
2224
                                chg_state(STATEID_SETTINGSMENU);
2225
                                break;
2226
                            case ACTIONID_VIBRATOGGLE:
2227
                                settings.do_vibra=!settings.do_vibra;
2228
                                chg_state(STATEID_SETTINGSMENU);
2229
                                break;
2230
 
2231
                            case ACTIONID_GRAPHTOGGLE:
2232
                                settings.do_scrollbg=!settings.do_scrollbg;
2233
                                load_images();
2234
                                chg_state(STATEID_SETTINGSMENU);
2235
                                break;
2236
 
2237
 
2238
                            case ACTIONID_FULLSCREENTOGGLE:
2239
                                settings.fullscreen=!settings.fullscreen;
2240
                                setFullScreenMode(settings.fullscreen);
2241
                                chg_state(STATEID_SETTINGSMENU);
2242
                                break;
2243
 
2244
//#if devicecontrol=="on"
2245
                            case ACTIONID_LIGHTTOGGLE:
2246
                                settings.keep_lighton =!settings.keep_lighton;
2247
                                chg_state(STATEID_SETTINGSMENU);
2248
                                break;
2249
//#endif
2250
 
2251
 
2252
                            case ACTIONID_WRITE_PARAMS:
2253
                                mk.write_params();
2254
                                chg_state(STATEID_MAINMENU);
2255
                                break;
2256
 
2257
                            case ACTIONID_UNDO_PARAMS:
2258
                                mk.params.use_backup();
2259
                                chg_state(STATEID_MAINMENU);
2260
                                break;
2261
 
2262
                            case ACTIONID_MAINMENU:
2263
                                chg_state(STATEID_MAINMENU);
2264
                                break;
2265
 
2266
                            case ACTIONID_DEBUG:
2267
                                debug.showing=true;
2268
                                break;
2269
 
2270
 
2271
 
2272
 
2273
                            case ACTIONID_TRAFFIC:
2274
                                chg_state(STATEID_TRAFFIC);
2275
                                break;
2276
 
2277
                            case ACTIONID_CONNECT_TCP:
2278
                                ipinput4proxy=false;
2279
                                chg_state(STATEID_IPINPUT);
2280
                                break;
2281
 
2282
                            case ACTIONID_SCAN_BT:
2283
                                chg_state(STATEID_SCANNING);
2284
                                break;
2285
 
2286
                            case ACTIONID_SELECT_COM:
2287
                                chg_state(STATEID_SELECT_COMPORT);
2288
                                break;
2289
 
2290
                            case ACTIONID_PROXY_INPUT:
2291
                                ipinput4proxy=true;
2292
                                chg_state(STATEID_IPINPUT);
2293
                                break;                     
2294
 
2295
                            }
2296
 
2297
                    }
2298
 
2299
                else menu_keypress(keyCode);
2300
 
2301
                break;
2302
 
2303
            case STATEID_SELECT_PARAMSET:
2304
                if ( getGameAction (keyCode)==FIRE )
2305
                    {              
2306
                        if ( mk.params.field[act_menu_select]!=null)
2307
                            {
2308
                                mk.params.act_paramset=act_menu_select;
2309
                                chg_state(STATEID_EDIT_PARAMS);
2310
                            }
2311
                    }
2312
                else menu_keypress(keyCode);
2313
                break;
2314
 
2315
//#if bluetooth=="on"
2316
            case STATEID_DEVICESELECT:
2317
 
2318
                if ( getGameAction (keyCode)==FIRE )
2319
                    {              
2320
 
2321
                        if (bt_scanner.remote_device_count > act_menu_select)
2322
                            {
2323
                                connect_mk("btspp://"+bt_scanner.remote_device_mac[act_menu_select] + ":1",bt_scanner.remote_device_name[act_menu_select]);
2324
                                chg_state(STATEID_CONN_DETAILS);
2325
                            }
2326
                        else
2327
                            {
2328
                                if (bt_scanner.remote_device_count == act_menu_select)
2329
                                    chg_state(STATEID_SCANNING);
2330
                                else
2331
                                    chg_state(STATEID_CONN_DETAILS);
2332
                            }
2333
 
2334
                    }
2335
                else menu_keypress(keyCode);
2336
 
2337
                break;
2338
//#endif
2339
 
2340
 
2341
            case STATEID_EDIT_PARAMS:
2342
                params_editor.keypress(keyCode,getGameAction (keyCode)) ;
2343
                break;
2344
 
2345
            case STATEID_FLIGHTVIEW:
2346
 
2347
                if ((keyCode >= this.KEY_NUM0) && (keyCode <= this.KEY_NUM9))              
2348
                        mk.LCD.set_page(keyCode-this.KEY_NUM0);
2349
                else
2350
                switch (getGameAction (keyCode))
2351
                    {
2352
                    case LEFT:
2353
                    case UP:
2354
                        mk.LCD.LCD_PREVPAGE();
2355
                        break;
2356
 
2357
                    case RIGHT:
2358
                    case DOWN:
2359
                        mk.LCD.LCD_NEXTPAGE();
2360
                        break;
2361
 
2362
 
2363
 
2364
                    }
2365
                break;
2366
            }
2367
 
2368
 
2369
 
2370
    }
2371
 
2372
 
2373
 
2374
 
2375
 
2376
 
2377
 
2378
 
2379
}
2380
 
2381