Debian Codegraph @

src/cap/cap110.cxx

raw
1 // ----------------------------------------------------------------------------
2 // Copyright (C) 2014
3 // David Freese, W1HKJ
4 //
5 // This file is part of flmsg
6 //
7 // flrig is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation; either version 3 of the License, or
10 // (at your option) any later version.
11 //
12 // flrig is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program. If not, see <http://www.gnu.org/licenses/>.
19 // ----------------------------------------------------------------------------
20
21 #include <stdlib.h>
22 #include <iostream>
23 #include <fstream>
24 #include <string>
25 #include <cstring>
26 #include <ctime>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <stdio.h>
30 #include <errno.h>
31
32 #include <FL/Fl.H>
33 #include <FL/Enumerations.H>
34 #include <FL/Fl_Window.H>
35 #include <FL/Fl_Button.H>
36 #include <FL/Fl_Group.H>
37 #include <FL/Fl_Sys_Menu_Bar.H>
38 #include <FL/x.H>
39 #include <FL/Fl_Help_Dialog.H>
40 #include <FL/Fl_Menu_Item.H>
41 #include <FL/Fl_File_Icon.H>
42
43 #include "config.h"
44 #include "flmsg_config.h"
45
46 #include "flmsg.h"
47 #include "templates.h"
48 #include "debug.h"
49 #include "util.h"
50 #include "gettext.h"
51 #include "flmsg_dialog.h"
52 #include "flinput2.h"
53 #include "date.h"
54 #include "calendar.h"
55 #include "icons.h"
56 #include "fileselect.h"
57 #include "wrap.h"
58 #include "status.h"
59 #include "parse_xml.h"
60 #include "flmsg_strings.h"
61
62 #ifdef WIN32
63 # include "flmsgrc.h"
64 # include "compat.h"
65 # define dirent fl_dirent_no_thanks
66 #endif
67
68 #include <FL/filename.H>
69 #include "dirent-check.h"
70
71 #include <FL/x.H>
72 #include <FL/Fl_Pixmap.H>
73 #include <FL/Fl_Image.H>
74
75 // ---------------------------------------------------------------------
76 // ics 110 field variables and template variables
77 // ---------------------------------------------------------------------
78
79 std::string cap110_mission_nbr = ":mnbr:";
80 std::string cap110_station = ":sta:";
81 std::string cap110_date = ":date:";
82 std::string cap110_ds_a = ":ds_a:";
83 std::string cap110_ds_b = ":ds_b:";
84 std::string cap110_ds_c = ":ds_c:";
85 std::string cap110_ds_d = ":ds_d:";
86 std::string cap110_ds_e = ":ds_e:";
87 std::string cap110_ds_f = ":ds_f:";
88
89 std::string cap110_comm_time = ":time[n]:"; // 23
90 std::string cap110_comm_chref = ":chref[n]:"; // 23
91 std::string cap110_comm_call = ":call[n]:"; // 23
92 std::string cap110_comm_rem = ":rem[n]:"; // 23
93
94 std::string s110_mission_nbr;
95 std::string s110_station;
96 std::string s110_date;
97 std::string s110_ds_a;
98 std::string s110_ds_b;
99 std::string s110_ds_c;
100 std::string s110_ds_d;
101 std::string s110_ds_e;
102 std::string s110_ds_f;
103
104 std::string s110_comm_time[23];
105 std::string s110_comm_call[23];
106 std::string s110_comm_chref[23];
107 std::string s110_comm_rem[23];
108
109 // =====================================================================
110
111 std::string buff_c110;
112 std::string cap110_def_filename= "";
113 std::string cap110_base_filename = "";
114 std::string cap110_def_template_name = "";
115 bool using_cap110_template = false;
116
117 void cap110_set_date()
118 {
119 std::string date = szCAPDateTime();
120 date.erase(2,6);
121 txt_110_date->value(date.c_str());
122 }
123
124 void clear_110fields()
125 {
126 s110_mission_nbr.clear();
127 s110_station.clear();
128 s110_date.clear();
129 s110_ds_a.clear();
130 s110_ds_b.clear();
131 s110_ds_c.clear();
132 s110_ds_d.clear();
133 s110_ds_e.clear();
134 s110_ds_f.clear();
135
136 for (int i = 0; i < 23; i++) {
137 s110_comm_time[i].clear();
138 s110_comm_call[i].clear();
139 s110_comm_chref[i].clear();
140 s110_comm_rem[i].clear();
141 }
142 }
143
144 bool check_110fields()
145 {
146 if (s110_mission_nbr != txt_110_mission_nbr->value())
147 return true;
148 if (s110_station != txt_110_station->value())
149 return true;
150 if (s110_date != txt_110_date->value())
151 return true;
152 if (s110_ds_a != txt_110_ds_a->value())
153 return true;
154 if (s110_ds_b != txt_110_ds_b->value())
155 return true;
156 if (s110_ds_c != txt_110_ds_c->value())
157 return true;
158 if (s110_ds_d != txt_110_ds_d->value())
159 return true;
160 if (s110_ds_e != txt_110_ds_e->value())
161 return true;
162 if (s110_ds_f != txt_110_ds_f->value())
163 return true;
164 for (int i = 0; i < 23; i++) {
165 if (s110_comm_time[i] != txt_110_comm_time[i]->value())
166 return true;
167 if (s110_comm_call[i] != txt_110_comm_call[i]->value())
168 return true;
169 if (s110_comm_chref[i] != txt_110_comm_chref[i]->value())
170 return true;
171 if (s110_comm_rem[i] != txt_110_comm_rem[i]->value())
172 return true;
173 }
174 return false;
175 }
176
177 void update_110fields()
178 {
179 s110_mission_nbr = txt_110_mission_nbr->value();
180 s110_station = txt_110_station->value();
181 s110_date = txt_110_date->value();
182 s110_ds_a = txt_110_ds_a->value();
183 s110_ds_b = txt_110_ds_b->value();
184 s110_ds_c = txt_110_ds_c->value();
185 s110_ds_d = txt_110_ds_d->value();
186 s110_ds_e = txt_110_ds_e->value();
187 s110_ds_f = txt_110_ds_f->value();
188 for (int i = 0; i < 23; i++) {
189 s110_comm_time[i] = txt_110_comm_time[i]->value();
190 s110_comm_call[i] = txt_110_comm_call[i]->value();
191 s110_comm_chref[i] = txt_110_comm_chref[i]->value();
192 s110_comm_rem[i] = txt_110_comm_rem[i]->value();
193 }
194 }
195
196 void update_110form()
197 {
198 txt_110_mission_nbr->value(s110_mission_nbr.c_str());
199 txt_110_station->value(s110_station.c_str());
200 txt_110_date->value(s110_date.c_str());
201 txt_110_ds_a->value(s110_ds_a.c_str());
202 txt_110_ds_b->value(s110_ds_b.c_str());
203 txt_110_ds_c->value(s110_ds_c.c_str());
204 txt_110_ds_d->value(s110_ds_d.c_str());
205 txt_110_ds_e->value(s110_ds_e.c_str());
206 txt_110_ds_f->value(s110_ds_f.c_str());
207
208 for (int i = 0; i < 23; i++) {
209 txt_110_comm_time[i]->value(s110_comm_time[i].c_str());
210 txt_110_comm_call[i]->value(s110_comm_call[i].c_str());
211 txt_110_comm_chref[i]->value(s110_comm_chref[i].c_str());
212 txt_110_comm_rem[i]->value(s110_comm_rem[i].c_str());
213 }
214 }
215
216 void clear_110_form()
217 {
218 clear_110fields();
219 update_110form();
220 }
221
222 std::string &cap110_nn(std::string & subst, int n)
223 {
224 static std::string garbage = "#$^*!";
225 static std::string ics;
226 ics.clear();
227 ics = subst;
228 size_t pos = ics.find("[");
229 if (pos == std::string::npos) return garbage;
230 pos++;
231 if (n < 10)
232 ics[pos] = '0' + n;
233 else {
234 ics[pos] = n > 19 ? '2' : '1';
235 ics[pos+1] = '0' + n % 10;
236 ics[pos+2] = ']';
237 ics += ':';
238 }
239 return ics;
240 }
241
242 void make_buff_c110(bool compress = false)
243 {
244 std::string mbuff;
245 mbuff.clear();
246 mbuff.append( lineout( cap110_mission_nbr, s110_mission_nbr ) );
247 mbuff.append( lineout( cap110_station, s110_station ) );
248 mbuff.append( lineout( cap110_date, s110_date ) );
249 mbuff.append( lineout( cap110_ds_a, s110_ds_a ) );
250 mbuff.append( lineout( cap110_ds_b, s110_ds_b ) );
251 mbuff.append( lineout( cap110_ds_c, s110_ds_c ) );
252 mbuff.append( lineout( cap110_ds_d, s110_ds_d ) );
253 mbuff.append( lineout( cap110_ds_e, s110_ds_e ) );
254 mbuff.append( lineout( cap110_ds_f, s110_ds_f ) );
255
256 for (int i = 0; i < 23; i++) {
257 mbuff.append( lineout( cap110_nn( cap110_comm_time, i ), s110_comm_time[i] ) );
258 mbuff.append( lineout( cap110_nn( cap110_comm_call, i ), s110_comm_call[i] ) );
259 mbuff.append( lineout( cap110_nn( cap110_comm_chref, i ), s110_comm_chref[i] ) );
260 mbuff.append( lineout( cap110_nn( cap110_comm_rem, i ), s110_comm_rem[i] ) );
261 }
262 if (compress) compress_maybe(mbuff);
263 buff_c110.append(mbuff);
264 }
265
266 void read_c110_buffer(std::string data)
267 {
268 clear_110fields();
269 read_header(data);
270
271 s110_mission_nbr = findstr( data, cap110_mission_nbr );
272 s110_station = findstr( data, cap110_station );
273 s110_date = findstr( data, cap110_date );
274 s110_ds_a = findstr( data, cap110_ds_a );
275 s110_ds_b = findstr( data, cap110_ds_b );
276 s110_ds_c = findstr( data, cap110_ds_c );
277 s110_ds_d = findstr( data, cap110_ds_d );
278 s110_ds_e = findstr( data, cap110_ds_e );
279 s110_ds_f = findstr( data, cap110_ds_f );
280
281 for (int i = 0; i < 23; i++) {
282 s110_comm_time[i] = findstr( data, cap110_nn( cap110_comm_time, i ) );
283 s110_comm_call[i] = findstr( data, cap110_nn( cap110_comm_call, i ) );
284 s110_comm_chref[i] = findstr( data, cap110_nn( cap110_comm_chref, i ) );
285 s110_comm_rem[i] = findstr( data, cap110_nn( cap110_comm_rem, i ) );
286 }
287
288 update_110form();
289
290 }
291
292 void cap110_cb_load_template(std::string data)
293 {
294 clear_110fields();
295 read_header(data);
296
297 s110_mission_nbr = findstr( data, cap110_mission_nbr );
298 s110_station = findstr( data, cap110_station );
299 s110_date = findstr( data, cap110_date );
300 s110_ds_a = findstr( data, cap110_ds_a );
301 s110_ds_b = findstr( data, cap110_ds_b );
302 s110_ds_c = findstr( data, cap110_ds_c );
303 s110_ds_d = findstr( data, cap110_ds_d );
304 s110_ds_e = findstr( data, cap110_ds_e );
305 s110_ds_f = findstr( data, cap110_ds_f );
306
307 for (int i = 0; i < 23; i++) {
308 s110_comm_time[i] = findstr( data, cap110_nn( cap110_comm_time, i ) );
309 s110_comm_call[i] = findstr( data, cap110_nn( cap110_comm_call, i ) );
310 s110_comm_chref[i] = findstr( data, cap110_nn( cap110_comm_chref, i ) );
311 s110_comm_rem[i] = findstr( data, cap110_nn( cap110_comm_rem, i ) );
312 }
313
314 update_110form();
315 }
316
317 void cap110_cb_new()
318 {
319 if (check_110fields()) {
320 if (fl_choice2(xMODIFIED, "No", xMODIFIED, NULL) == 1) {
321 update_header(CHANGED);
322 cap110_cb_save();
323 }
324 }
325 clear_110_form();
326 clear_header();
327 cap110_def_filename= ICS_msg_dir;
328 cap110_def_filename.append(xNEW).append(CAP110_FILE_EXT);
329 show_filename(cap110_def_filename);
330 using_cap110_template = false;
331 }
332
333 void cap110_cb_import()
334 {
335 fl_alert2(xNOTIMPLEMENTED);
336 }
337
338 void cap110_cb_export()
339 {
340 fl_alert2(xNOTIMPLEMENTED);
341 }
342
343 void cap110_cb_wrap_import(std::string wrapfilename, std::string inpbuffer)
344 {
345 clear_110_form();
346 cap110_cb_load_template(inpbuffer);
347 cap110_def_filename= ICS_msg_dir;
348 cap110_def_filename.append(wrapfilename);
349 show_filename(cap110_def_filename);
350 using_cap110_template = false;
351 }
352
353 int eval_cap110_fsize()
354 {
355 Ccrc16 chksum;
356 evalstr.assign("[WRAP:beg][WRAP:lf][WRAP:fn ");
357 evalstr.append(cap110_base_filename).append("]");
358 update_110fields();
359 update_header(FROM);
360 evalstr.append(header("<cap110>"));
361 buff_c110.clear();
362 make_buff_c110(true);
363 if (buff_c110.empty()) return 0;
364 compress_maybe( buff_c110 );
365 evalstr.append( buff_c110 );
366 evalstr.append("[WRAP:chksum ").append(chksum.scrc16(evalstr)).append("][WRAP:end]");
367 return evalstr.length();
368 }
369
370 void cap110_cb_wrap_export()
371 {
372 if (check_110fields()) {
373 if (fl_choice2(xMODIFIED, "No", xMODIFIED, NULL) == 0)
374 return;
375 update_header(CHANGED);
376 }
377 update_110fields();
378
379 if (cap110_base_filename == std::string(xNEW).append(CAP110_FILE_EXT) ||
380 cap110_base_filename == std::string(xDEFAULT).append(CAP110_FILE_EXT) )
381 if (!cap110_cb_save_as()) return;
382
383 std::string wrapfilename = WRAP_send_dir;
384 wrapfilename.append(cap110_base_filename);
385 wrapfilename.append(".wrap");
386 const char *p = FSEL::saveas(
387 xSAVEASWRAP,
388 xWRAPFILE,
389 wrapfilename.c_str());
390 if (p) {
391 std::string pext = fl_filename_ext(p);
392 wrapfilename = p;
393 update_header(FROM);
394 buff_c110.assign(header("<cap110>"));
395 make_buff_c110(true);
396 export_wrapfile(cap110_base_filename, wrapfilename, buff_c110, pext != ".wrap");
397 write_110(cap110_def_filename);
398 }
399 }
400
401 void cap110_cb_wrap_autosend()
402 {
403 if (check_110fields()) {
404 if (fl_choice2(xMODIFIED, "No", xMODIFIED, NULL) == 0)
405 return;
406 update_header(CHANGED);
407 }
408 update_110fields();
409
410 if (cap110_base_filename == std::string(xNEW).append(CAP110_FILE_EXT) ||
411 cap110_base_filename == std::string(xDEFAULT).append(CAP110_FILE_EXT) )
412 cap110_cb_save_as();
413
414 update_header(FROM);
415 buff_c110.assign(header("<cap110>"));
416 make_buff_c110(true);
417
418 xfr_via_socket(cap110_base_filename, buff_c110);
419 write_110(cap110_def_filename);
420 }
421
422 void cap110_cb_load_template()
423 {
424 std::string cap110_def_filename= cap110_def_template_name;
425 const char *p = FSEL::select(
426 xOPENTEMPLATE,
427 std::string(xTEMPLATEFILE).append(CAP110_TEMP_EXT).c_str(),
428 cap110_def_filename.c_str());
429 if (p) {
430 clear_110_form();
431 read_data_file(p);
432 cap110_def_template_name = p;
433 show_filename(cap110_def_template_name);
434 using_cap110_template = true;
435 }
436 }
437
438 void cap110_cb_save_template()
439 {
440 if (!using_cap110_template) {
441 cap110_cb_save_as_template();
442 return;
443 }
444 std::string cap110_def_filename= cap110_def_template_name;
445 const char *p = FSEL::saveas(
446 xSAVEASTEMPLATE,
447 std::string(xTEMPLATEFILE).append(CAP110_TEMP_EXT).c_str(),
448 cap110_def_filename.c_str());
449 if (p) {
450 update_header(CHANGED);
451 buff_c110.assign(header("<cap110>"));
452 make_buff_c110();
453 write_110(p);
454 }
455 }
456
457 void cap110_cb_save_as_template()
458 {
459 std::string cap110_def_filename= cap110_def_template_name;
460 const char *p = FSEL::saveas(
461 xSAVEASTEMPLATE,
462 std::string(xTEMPLATEFILE).append(CAP110_TEMP_EXT).c_str(),
463 cap110_def_filename.c_str());
464 if (p) {
465 const char *pext = fl_filename_ext(p);
466 cap110_def_template_name = p;
467 if (strlen(pext) == 0) cap110_def_template_name.append(CAP110_TEMP_EXT);
468 remove_spaces_from_filename(cap110_def_template_name);
469 clear_header();
470 update_header(CHANGED);
471 buff_c110.assign(header("<cap110>"));
472 make_buff_c110();
473 write_110(cap110_def_template_name);
474 show_filename(cap110_def_template_name);
475 using_cap110_template = true;
476 }
477 }
478
479 void cap110_cb_open()
480 {
481 const char *p = FSEL::select(
482 _(xOPENDATAFILE),
483 std::string("CAP-110\t*").append(CAP110_FILE_EXT).c_str(),
484 cap110_def_filename.c_str());
485 if (!p) return;
486 if (strlen(p) == 0) return;
487 clear_110_form();
488 read_data_file(p);
489 using_cap110_template = false;
490 cap110_def_filename= p;
491 show_filename(cap110_def_filename);
492 }
493
494 void write_110(std::string s)
495 {
496 FILE *file110 = fopen(s.c_str(), "w");
497 if (!file110) return;
498
499 fwrite(buff_c110.c_str(), buff_c110.length(), 1, file110);
500 fclose(file110);
501 }
502
503 bool cap110_cb_save_as()
504 {
505 const char *p;
506 std::string newfilename;
507
508 std::string name = named_file();
509 if (!name.empty()) {
510 name.append(CAP110_FILE_EXT);
511 newfilename = ICS_msg_dir;
512 newfilename.append(name);
513 } else
514 newfilename = cap110_def_filename;
515
516 p = FSEL::saveas(
517 _(xSAVEDATAFILE),
518 std::string("CAP-110\t*").append(CAP110_FILE_EXT).c_str(),
519 newfilename.c_str());
520
521 if (!p) return false;
522 if (strlen(p) == 0) return false;
523
524 if (progStatus.sernbr_fname) update_sernbr();
525
526 const char *pext = fl_filename_ext(p);
527 cap110_def_filename= p;
528 if (strlen(pext) == 0) cap110_def_filename.append(CAP110_FILE_EXT);
529
530 remove_spaces_from_filename(cap110_def_filename);
531 update_110fields();
532 update_header(NEW);
533 buff_c110.assign(header("<cap110>"));
534 make_buff_c110();
535 write_110(cap110_def_filename);
536
537 using_cap110_template = false;
538 show_filename(cap110_def_filename);
539 return true;
540 }
541
542 void cap110_cb_save()
543 {
544 if (cap110_base_filename == std::string(xNEW).append(CAP110_FILE_EXT) ||
545 cap110_base_filename == std::string(xDEFAULT).append(CAP110_FILE_EXT) ||
546 using_cap110_template == true) {
547 cap110_cb_save_as();
548 return;
549 }
550 if (check_110fields()) update_header(CHANGED);
551 update_110fields();
552 buff_c110.assign(header("<cap110>"));
553 make_buff_c110();
554 write_110(cap110_def_filename);
555 using_cap110_template = false;
556 }
557
558 void cap110_cb_html()
559 {
560 std::string fname_name = fl_filename_name(cap110_def_filename.c_str());
561 size_t p = fname_name.rfind('.');
562 if (p != std::string::npos) fname_name.erase(p);
563
564 std::string cap110_fname = ICS_dir;
565 cap110_fname.append(fname_name);
566 cap110_fname.append(".html");
567
568 std::string html_text = "";
569 std::string empty = "<br>";
570
571 update_110fields();
572 std::string form110 = cap110_html_template;
573
574 replacestr(form110, TITLE, fname_name);
575 replacestr(form110, cap110_mission_nbr, s110_mission_nbr );
576 replacestr(form110, cap110_station, s110_station );
577 replacestr(form110, cap110_date, s110_date );
578 replacestr(form110, cap110_ds_a, s110_ds_a );
579 replacestr(form110, cap110_ds_b, s110_ds_b );
580 replacestr(form110, cap110_ds_c, s110_ds_c );
581 replacestr(form110, cap110_ds_d, s110_ds_d );
582 replacestr(form110, cap110_ds_e, s110_ds_e );
583 replacestr(form110, cap110_ds_f, s110_ds_f );
584
585 for (int i = 0; i < 23; i++) {
586 replacestr(form110, cap110_nn( cap110_comm_time, i ),
587 s110_comm_time[i].empty() ? empty : s110_comm_time[i] );
588 replacestr(form110, cap110_nn( cap110_comm_call, i ),
589 s110_comm_call[i].empty() ? empty : s110_comm_call[i] );
590 replacestr(form110, cap110_nn( cap110_comm_chref, i ),
591 s110_comm_chref[i].empty() ? empty : s110_comm_chref[i] );
592 replacestr(form110, cap110_nn( cap110_comm_rem, i ),
593 s110_comm_rem[i].empty() ? empty : s110_comm_rem[i] );
594 }
595
596 FILE *file110 = fopen(cap110_fname.c_str(), "w");
597 fprintf(file110,"%s", form110.c_str());
598 fclose(file110);
599
600 open_url(cap110_fname.c_str());
601 }
602
603 void cap110_cb_msg_type()
604 {
605 if (tabs_msg_type->value() == tab_cap110 )
606 show_filename(cap110_def_filename);
607 }
608
609 void cap110_cb_textout()
610 {
611 std::string cap110_fname = ICS_dir;
612 cap110_fname.append("cap110.txt");
613
614 update_110fields();
615 std::string form110 = cap110_text_template;
616
617 replacestr(form110, cap110_mission_nbr, s110_mission_nbr );
618 replacestr(form110, cap110_station, s110_station );
619 replacestr(form110, cap110_date, s110_date );
620 replacestr(form110, cap110_ds_a, s110_ds_a );
621 replacestr(form110, cap110_ds_b, s110_ds_b );
622 replacestr(form110, cap110_ds_c, s110_ds_c );
623 replacestr(form110, cap110_ds_d, s110_ds_d );
624 replacestr(form110, cap110_ds_e, s110_ds_e );
625 replacestr(form110, cap110_ds_f, s110_ds_f );
626
627 std::string logdata;
628 std::string lgdata = xLOGDATA;
629 const char *fmt = "%-7s|%-12s|%-15s|%s\n";
630 char tempstr[200];
631 snprintf(tempstr, sizeof(tempstr), fmt, "TIME", "CALL", "CH REF", "REMARKS");
632
633 logdata = tempstr;
634 for (int i = 0; i < 23; i++) {
635 if (!s110_comm_time[i].empty() ||
636 !s110_comm_call[i].empty() ||
637 !s110_comm_chref[i].empty() ||
638 !s110_comm_rem[i].empty() ) {
639 snprintf(tempstr, sizeof(tempstr), fmt,
640 s110_comm_time[i].c_str(),
641 s110_comm_call[i].c_str(),
642 s110_comm_chref[i].c_str(),
643 s110_comm_rem[i].c_str());
644 logdata.append(tempstr);
645 }
646 }
647 replacestr(form110, lgdata, logdata);
648
649 FILE *file110 = fopen(cap110_fname.c_str(), "w");
650 fprintf(file110,"%s", form110.c_str());
651 fclose(file110);
652
653 open_url(cap110_fname.c_str());
654 }
655