fd173764f8eab5d61e4d4218c986e0a3af099422
[goodguy/history.git] / swindow.C
1
2 #include "bchash.h"
3 #include "bctimer.h"
4 #include "condition.h"
5 #include "cstrdup.h"
6 #include "edl.h"
7 #include "filesystem.h"
8 #include "language.h"
9 #include "localsession.h"
10 #include "mainerror.h"
11 #include "mainmenu.h"
12 #include "mainsession.h"
13 #include "mainundo.h"
14 #include "mwindow.h"
15 #include "mwindowgui.h"
16 #include "mutex.h"
17 #include "strack.h"
18 #include "swindow.h"
19 #include "theme.h"
20 #include "track.h"
21 #include "tracks.h"
22
23 #include<ctype.h>
24 #include<errno.h>
25 #include<stdint.h>
26 #include<stdlib.h>
27 #include<string.h>
28 #include<unistd.h>
29
30 SWindowOK::SWindowOK(SWindowGUI *gui, int x, int y)
31  : BC_OKButton(x, y)
32 {
33         this->gui = gui;
34 }
35
36 SWindowOK::~SWindowOK()
37 {
38 }
39
40 int SWindowOK::button_press_event()
41 {
42         if(get_buttonpress() == 1 && is_event_win() && cursor_inside()) {
43                 gui->stop(0);
44                 return 1;
45         }
46         return 0;
47 }
48
49 int SWindowOK::keypress_event()
50 {
51         return 0;
52 }
53
54
55 SWindowCancel::SWindowCancel(SWindowGUI *gui, int x, int y)
56  : BC_CancelButton(x, y)
57 {
58         this->gui = gui;
59 }
60
61 SWindowCancel::~SWindowCancel()
62 {
63 }
64
65 int SWindowCancel::button_press_event()
66 {
67         if(get_buttonpress() == 1 && is_event_win() && cursor_inside()) {
68                 gui->stop(1);
69                 return 1;
70         }
71         return 0;
72 }
73
74
75 SWindowLoadPath::SWindowLoadPath(SWindowGUI *gui, int x, int y, char *path)
76  : BC_TextBox(x, y, 200, 1, path)
77 {
78         this->sw_gui = gui;
79 }
80
81 SWindowLoadPath::~SWindowLoadPath()
82 {
83 }
84
85 int SWindowLoadPath::handle_event()
86 {
87         calculate_suggestions();
88         strcpy(sw_gui->script_path, get_text());
89         return 1;
90 }
91
92
93 SWindowLoadFile::SWindowLoadFile(SWindowGUI *gui, int x, int y)
94  : BC_GenericButton(x, y, _("Load"))
95 {
96         this->sw_gui = gui;
97 }
98
99 SWindowLoadFile::~SWindowLoadFile()
100 {
101 }
102
103 int SWindowLoadFile::handle_event()
104 {
105         if( sw_gui->script_path[0] ) {
106                 sw_gui->load_path->set_suggestions(0,0);
107                 sw_gui->load_script();
108                 sw_gui->set_script_pos(0);
109         }
110         else {
111                 eprintf(_("script text file path required"));
112         }
113         return 1;
114 }
115
116 SWindowSaveFile::SWindowSaveFile(SWindowGUI *gui, int x, int y)
117  : BC_GenericButton(x, y, _("Save"))
118 {
119         this->sw_gui = gui;
120 }
121
122 SWindowSaveFile::~SWindowSaveFile()
123 {
124 }
125
126 int SWindowSaveFile::handle_event()
127 {
128         if( sw_gui->script_path[0] ) {
129                 sw_gui->save_spumux_data();
130         }
131         else {
132                 eprintf(_("script microdvd file path required"));
133         }
134         return 1;
135 }
136
137
138
139
140 void SWindowGUI::create_objects()
141 {
142         int x = 10, y = 10;
143         BC_Title *title = new BC_Title(x, y, _("Path:"));
144         add_subwindow(title);
145         int x1 = x + title->get_w() + pad, y1 = y;
146         load_path = new SWindowLoadPath(this, x1, y1, script_path);
147         add_subwindow(load_path);
148         x1 += load_path->get_w() + 2*pad;
149         add_subwindow(load_file = new SWindowLoadFile(this, x1, y1));
150         x1 += load_file->get_w() + 2*pad;
151         add_subwindow(save_file = new SWindowSaveFile(this, x1, y1));
152         y += max(load_path->get_h(), load_file->get_h()) + pad;
153         x1 = x + pad, y1 = y;
154         BC_Title *title1, *title2;
155         add_subwindow(title1 = new BC_Title(x1, y1, _("File Size:")));
156         y += title1->get_h() + pad;
157         int y2 = y;
158         add_subwindow(title2 = new BC_Title(x1, y2, _("Entries:")));
159         int x2 = x1 + max(title1->get_w(), title2->get_w()) + pad;
160         add_subwindow(script_filesz = new BC_Title(x2, y1, "0", MEDIUMFONT, YELLOW));
161         add_subwindow(script_entries = new BC_Title(x2, y2, "0", MEDIUMFONT, YELLOW));
162         int x3 = x2 + max(script_entries->get_w()*8, script_filesz->get_w()*8) + pad;
163         add_subwindow(title1 = new BC_Title(x3, y1, _("Lines:")));
164         add_subwindow(title2 = new BC_Title(x3, y2, _("Texts:")));
165         int x4 = x3 + max(title1->get_w(), title2->get_w()) + pad;
166         add_subwindow(script_lines = new BC_Title(x4, y1, "0", MEDIUMFONT, YELLOW));
167         add_subwindow(script_texts = new BC_Title(x4, y2, "0", MEDIUMFONT, YELLOW));
168         int x5 = x4 + max(script_lines->get_w()*8, script_texts->get_w()*8) + 2*pad;
169         add_subwindow(prev_script = new ScriptPrev(this, x5, y1));
170         add_subwindow(next_script = new ScriptNext(this, x5, y2));
171         int x6 = x5 + max(prev_script->get_w(), next_script->get_w()) + 2*pad;
172         add_subwindow(paste_script = new ScriptPaste(this, x6, y1));
173         add_subwindow(clear_script = new ScriptClear(this, x6, y2));
174         y += max(title1->get_h(), title2->get_h()) + 2*pad;
175
176         script_position = new ScriptPosition(this, x, y, 100);
177         script_position->create_objects();
178         x1 = x + script_position->get_w() + pad;
179         add_subwindow(script_scroll = new ScriptScroll(this, x1, y, get_w()-x1-pad));
180         y += script_scroll->get_h() + 2*pad;
181         x1 = x + pad;
182         blank_line = new char[2];
183         blank_line[0] = ' ';  blank_line[1] = 0;
184         add_subwindow(script_title = new BC_Title(x1, y, _("Script Text:")));
185         y += script_title->get_h() + pad;
186         int rows = (ok_y - y - BC_Title::calculate_h(this,_("Line Text:")) -
187                 4*pad) / text_rowsz - 4;
188         int w1 = get_w() - x1 - pad;
189         script_entry = new ScriptEntry(this, x1, y, w1, rows, blank_line);
190         script_entry->create_objects();
191         y += script_entry->get_h() + pad;
192         add_subwindow(line_title = new BC_Title(x1, y, _("Line Text:")));
193         y += line_title->get_h() + pad;
194         line_entry = new ScriptEntry(this, x1, y, w1, 4);
195         line_entry->create_objects();
196         ok = new SWindowOK(this, ok_x, ok_y);
197         add_subwindow(ok);
198         cancel = new SWindowCancel(this, cancel_x, cancel_y);
199         add_subwindow(cancel);
200 }
201
202 void SWindowGUI::load()
203 {
204         const char *script_text =
205         _("Adding Subtitles: quick \"How To\" (= or * indicates comment)\n"
206         "*2345678901234567890123456789012345678901234567890123456789\n"
207         "For regular DVD subtitles, put script in a text file. "
208         "Lines can be any length but they will be broken up "
209         "to fit according to some criteria below.\n"
210         "Running text used as script lines will be broken into multilple lines.\n"
211         "The target line length is 60 characters.\n"
212         "Punctuation may be flagged to create an early line break.\n"
213         "Single carriage return ends an individual script line.\n"
214         "Double carriage return indicates the end of an entry.\n"
215         "Whitespace at beginning or end of line is removed.\n"
216         "You can edit the active line in the Line Text box.\n"
217         "\n"
218         "== A new entry is here for illustration purposes.\n"
219         "*  Entry 2\n"
220         "This is the second entry.\n");
221
222         if( script_path[0] && !access(script_path,R_OK) ) {
223                 load_script();
224         }
225         else {
226                 script_path[0] = 0;
227                 load_path->update(script_path);
228                 FILE *fp = fmemopen((void *)script_text, strlen(script_text), "r");
229                 load_script(fp);
230         }
231         int text_no = script_text_no;
232         script_text_no = -1;
233         load_selection(script_entry_no, text_no);
234 }
235
236 SWindowGUI::SWindowGUI(SWindow *swindow, int x, int y, int w, int h)
237  : BC_Window(_(PROGRAM_NAME ": Subtitle"), x, y, w, h, 600, 500,
238         1, 0, 0 , -1, swindow->mwindow->get_cwindow_display())
239 {
240         this->swindow = swindow;
241         pad = 8;
242
243         ok = 0;
244         ok_w = BC_OKButton::calculate_w();
245         ok_h = BC_OKButton::calculate_h();
246         ok_x = 10;
247         ok_y = h - ok_h - 10;
248         cancel = 0;
249         cancel_w = BC_CancelButton::calculate_w();
250         cancel_h = BC_CancelButton::calculate_h();
251         cancel_x = w - cancel_w - 10,
252         cancel_y = h - cancel_h - 10;
253
254         load_path = 0;
255         load_file = 0;
256         save_file = 0;
257         script_filesz = 0;
258         script_lines = 0;
259         script_entries = 0;
260         script_texts = 0;
261         script_entry_no = 0;
262         script_text_no = 0;
263         script_line_no = 0;
264         script_text_lines = 0;
265         prev_script = 0;
266         next_script = 0;
267         paste_script = 0;
268         clear_script = 0;
269         script_position = 0;
270         script_entry = 0;
271         line_entry = 0;
272         script_scroll = 0;
273         blank_line = 0;
274         text_font = MEDIUMFONT;
275         text_rowsz = get_text_ascent(text_font)+1 + get_text_descent(text_font)+1;
276 }
277
278 SWindowGUI::~SWindowGUI()
279 {
280         delete script_entry;
281         delete line_entry;
282         delete script_position;
283         delete [] blank_line;
284 }
285
286 void SWindowGUI::stop(int v)
287 {
288         if( !swindow->gui_done ) {
289                 swindow->gui_done = 1;
290                 set_done(v);
291         }
292 }
293
294 int SWindowGUI::translation_event()
295 {
296         swindow->mwindow->session->swindow_x = get_x();
297         swindow->mwindow->session->swindow_y = get_y();
298         return 0;
299 }
300
301 int SWindowGUI::resize_event(int w, int h)
302 {
303         swindow->mwindow->session->swindow_w = w;
304         swindow->mwindow->session->swindow_h = h;
305
306         ok_x = 10;
307         ok_y = h - ok_h - 10;
308         ok->reposition_window(ok_x, ok_y);
309         cancel_x = w - cancel_w - 10,
310         cancel_y = h - cancel_h - 10;
311         cancel->reposition_window(cancel_x, cancel_y);
312
313         int x = script_position->get_x();
314         int y = script_position->get_y();
315         int hh = script_position->get_h();
316         int ww = script_position->get_w();
317         int x1 = x + ww + pad;
318         int w1 = w - x1 - pad;
319         script_scroll->reposition_window(x1, y, w1);
320         y += hh + 2*pad;
321         script_title->reposition_window(x, y);
322         y += script_title->get_h() + pad;
323         w1 = w - x - pad;
324         int rows = (ok_y - y - line_title->get_h() - 4*pad) / text_rowsz - 4;
325         script_entry->reposition_window(x, y, w1, rows);
326         y += script_entry->get_h() + 2*pad;
327         line_title->reposition_window(x, y);
328         y += line_title->get_h() + pad;
329         line_entry->reposition_window(x, y, w1, 4);
330         return 0;
331 }
332
333 void SWindowGUI::load_defaults()
334 {
335         BC_Hash *defaults = swindow->mwindow->defaults;
336         defaults->get("SUBTTL_SCRIPT_PATH", script_path);
337         script_entry_no = defaults->get("SUBTTL_SCRIPT_ENTRY_NO", script_entry_no);
338         script_text_no = defaults->get("SUBTTL_SCRIPT_TEXT_NO", script_text_no);
339 }
340
341 void SWindowGUI::save_defaults()
342 {
343         BC_Hash *defaults = swindow->mwindow->defaults;
344         defaults->update("SUBTTL_SCRIPT_PATH", script_path);
345         defaults->update("SUBTTL_SCRIPT_ENTRY_NO", script_entry_no);
346         defaults->update("SUBTTL_SCRIPT_TEXT_NO", script_text_no);
347 }
348
349 void SWindowGUI::set_script_pos(int64_t entry_no, int text_no)
350 {
351         script_entry_no = entry_no<0 ? 0 :
352                 entry_no>script.size()-1 ? script.size()-1 : entry_no;
353         script_text_no = text_no-1;
354         load_next_selection();
355 }
356
357 int SWindowGUI::load_selection(int pos, int row)
358 {
359         if( pos < 0 || pos >= script.size() ) return 1;
360         ScriptLines *texts = script[pos];
361         char *rp = texts->get_text_row(row);
362         if( !rp || *rp == '=' || *rp == '*' || *rp=='\n' ) return 1;
363         if( pos != script_entry_no || script_text_no < 0 ) {
364                 script_entry_no = pos;
365                 script_scroll->update_value(script_entry_no);
366                 script_position->update(script_entry_no);
367                 script_entry->set_text(texts->text);
368                 script_entry->set_text_row(0);
369         }
370         script_text_no = row;
371         char line[BCTEXTLEN], *bp = line;
372         char *ep = bp+sizeof(line)-1, *cp = rp;
373         while( bp < ep && *cp && *cp!='\n' ) *bp++ = *cp++;
374         *bp = 0;  bp = texts->text;
375         int char1 = rp-bp, char2 = cp-bp;
376         script_entry->set_selection(char1, char2, char2);
377         int rows = script_entry->get_rows();
378         int rows2 = rows / 2;
379         int rows1 = texts->lines+1 - rows;
380         if( (row-=rows2) > rows1 ) row = rows1;
381         if( row < 0 ) row = 0;
382         script_entry->set_text_row(row);
383         line_entry->update(line);
384         line_entry->set_text_row(0);
385         return 0;
386 }
387
388 int SWindowGUI::load_prev_selection()
389 {
390         int pos = script_entry_no, row = script_text_no;
391         if( pos < 0 || pos >= script.size() ) return 1;
392         for(;;) {
393                 if( --row < 0 ) {
394                         if( --pos < 0 ) break;
395                         row = script[pos]->lines;
396                         continue;
397                 }
398                 if( !load_selection(pos, row) )
399                         return 0;
400         }
401         return 1;
402 }
403
404 int SWindowGUI::load_next_selection()
405 {
406         int pos = script_entry_no, row = script_text_no;
407         if( pos < 0 || pos >= script.size() ) return 1;
408         for(;;) {
409                 if( ++row >= script[pos]->lines ) {
410                         if( ++pos >= script.size() ) break;
411                         row = -1;
412                         continue;
413                 }
414                 if( !load_selection(pos, row) )
415                         return 0;
416         }
417         return 1;
418 }
419
420 int SWindowGUI::update_selection()
421 {
422         EDL *edl = swindow->mwindow->edl;
423         LocalSession *lsn = edl->local_session;
424         double position = lsn->get_selectionstart();
425         Edit *edit = 0;
426         Tracks *tracks = edl->tracks;
427         for( Track *track=tracks->first; track && !edit; track=track->next ) {
428                 if( !track->record ) continue;
429                 if( track->data_type != TRACK_SUBTITLE ) continue;
430                 int64_t pos = track->to_units(position,0);
431                 edit = track->edits->editof(pos, PLAY_FORWARD, 0);
432         }
433         if( !edit ) return 1;
434         SEdit *sedit = (SEdit *)edit;
435         line_entry->update(sedit->get_text());
436         line_entry->set_text_row(0);
437         return 0;
438 }
439
440 int MWindow::paste_subtitle_text(char *text, double start, double end)
441 {
442         gui->lock_window("MWindow::paste_subtitle_text 1");
443         undo->update_undo_before();
444
445         Tracks *tracks = edl->tracks;
446         for( Track *track=tracks->first; track; track=track->next ) {
447                 if( track->data_type != TRACK_SUBTITLE ) continue;
448                 if( !track->record ) continue;
449                 int64_t start_i = track->to_units(start, 0);
450                 int64_t end_i = track->to_units(end, 1);
451                 track->edits->clear(start_i,end_i);
452                 SEdit *sedit = (SEdit *)track->edits->create_silence(start_i,end_i);
453                 strcpy(sedit->get_text(),text);
454                 track->edits->optimize();
455         }
456
457         save_backup();
458         undo->update_undo_after(_("paste subttl"), LOAD_EDITS | LOAD_PATCHES);
459
460         sync_parameters(CHANGE_EDL);
461         restart_brender();
462         gui->update(0, 1, 1, 0, 0, 0, 0);
463         gui->unlock_window();
464
465         return 0;
466 }
467
468 int SWindowGUI::paste_text(const char *text, double start, double end)
469 {
470         char stext[BCTEXTLEN], *cp = stext;
471         if( text ) { // remap charset, reformat if needed
472                 for( const char *bp=text; *bp!=0; ++bp,++cp ) {
473                         switch( *bp ) {
474                         case '\n':  *cp = '|';  break;
475                         default:    *cp = *bp;  break;
476                         }
477                 }
478         }
479         if( cp > stext && *(cp-1) == '|' ) --cp;
480         *cp = 0;
481         return swindow->mwindow->paste_subtitle_text(stext, start, end);
482 }
483
484 int SWindowGUI::paste_selection()
485 {
486         EDL *edl = swindow->mwindow->edl;
487         LocalSession *lsn = edl->local_session;
488         double start = lsn->get_selectionstart();
489         double end = lsn->get_selectionend();
490         if( start >= end ) return 1;
491         if( lsn->inpoint_valid() && lsn->outpoint_valid() ) {
492                 lsn->set_inpoint(lsn->get_outpoint());
493                 lsn->unset_outpoint();
494         }
495         paste_text(line_entry->get_text(), start, end);
496         load_next_selection();
497         return 0;
498 }
499
500 int SWindowGUI::clear_selection()
501 {
502         EDL *edl = swindow->mwindow->edl;
503         double start = edl->local_session->get_selectionstart();
504         double end = edl->local_session->get_selectionend();
505         if( end > start )
506                 paste_text(0, start, end);
507         return 0;
508 }
509
510
511 ScriptPrev::ScriptPrev(SWindowGUI *gui, int x, int y)
512  : BC_GenericButton(x, y, _("Prev"))
513 {
514         sw_gui = gui;
515 }
516
517 ScriptPrev::~ScriptPrev()
518 {
519 }
520
521 int ScriptPrev::handle_event()
522 {
523         sw_gui->load_prev_selection();
524         return 1;
525 }
526
527 ScriptNext::ScriptNext(SWindowGUI *gui, int x, int y)
528  : BC_GenericButton(x, y, _("Next"))
529 {
530         sw_gui = gui;
531 }
532
533 ScriptNext::~ScriptNext()
534 {
535 }
536
537 int ScriptNext::handle_event()
538 {
539         sw_gui->load_next_selection();
540         return 1;
541 }
542
543 ScriptPaste::ScriptPaste(SWindowGUI *gui, int x, int y)
544  : BC_GenericButton(x, y, _("Paste"))
545 {
546         sw_gui = gui;
547 }
548
549 ScriptPaste::~ScriptPaste()
550 {
551 }
552
553 int ScriptPaste::handle_event()
554 {
555         sw_gui->paste_selection();
556         return 1;
557 }
558
559 ScriptClear::ScriptClear(SWindowGUI *gui, int x, int y)
560  : BC_GenericButton(x, y, _("Clear"))
561 {
562         sw_gui = gui;
563 }
564
565 ScriptClear::~ScriptClear()
566 {
567 }
568
569 int ScriptClear::handle_event()
570 {
571         sw_gui->clear_selection();
572         return 1;
573 }
574
575
576 ScriptLines::ScriptLines()
577 {
578         used = 0;
579         lines = 0;
580         text = new char[allocated = 256];
581         *text = 0;
582 }
583
584 ScriptLines::~ScriptLines()
585 {
586         delete [] text;
587 }
588
589 void ScriptLines::append(char *cp)
590 {
591         int len = strlen(cp);
592         if( allocated-used < len+1 ) {
593                 int isz = allocated + used + len;
594                 char *new_text = new char[isz];
595                 allocated = isz;
596                 memcpy(new_text, text, used);
597                 delete [] text;  text = new_text;
598         }
599         memcpy(text+used, cp, len);
600         text[used += len] = 0;
601         ++lines;
602 }
603
604 int ScriptLines::break_lines()
605 {
606         int line_limit = 60;
607         int limit2 = line_limit/2;
608         int limit4 = line_limit/4-2;
609         char *cp = text, *dp = cp+used;
610         int n;  char *bp, *ep, *pp, *sp;
611         for( lines=0; cp<dp; ++lines ) {
612                 // find end of line/buffer
613                 for( ep=cp; ep<dp && *ep!='\n'; ++ep );
614                 // delete trailing spaces
615                 for( sp=ep; sp>=cp && (!*sp || isspace(*sp)); --sp);
616                 ++sp;
617                 if( (n=ep-sp) > 0 ) {
618                         memmove(sp,ep,dp+1-ep);
619                         used -= n;  dp -= n;  ep -= n;
620                 }
621                 ++ep;
622                 // skip, if comment or title line
623                 if( *cp == '*' || *cp == '=' ) {
624                         cp = ep;  continue;
625                 }
626                 // delete leading spaces
627                 for( sp=cp; sp<ep && isspace(*sp); ++sp);
628                 if( (n=sp-cp) > 0 ) {
629                         memmove(cp,sp,dp+1-sp);
630                         used -= n;  dp -= n;  ep -= n;
631                 }
632                 // target about half remaining line, constrain line_limit
633                 if( (n=(ep-1-cp)/2) < limit2 || n > line_limit )
634                         n = line_limit;
635                 // search for last punct, last space before line_limit
636                 for( bp=cp, pp=sp=0; --n>=0 && cp<ep; ++cp ) {
637                         if( ispunct(*cp) && isspace(*(cp+1)) ) pp = cp;
638                         else if( isspace(*cp) ) sp = cp;
639                 }
640                 // line not empty
641                 if( cp < ep ) {
642                         // first, after punctuation
643                         if( pp && pp-bp >= limit4 )
644                                 cp = pp+1;
645                         // then, on spaces
646                         else if( sp ) {
647                                 cp = sp;
648                         }
649                         // last, on next space
650                         else {
651                                 while( cp<dp && !isspace(*cp) ) ++cp;
652                         }
653                         // add new line
654                         if( !*cp ) break;
655                         *cp++ = '\n';
656                 }
657         }
658         return lines;
659 }
660
661 int ScriptLines::get_text_rows()
662 {
663         int ret = 1, i=used;
664         for( char *cp=text; --i>=0; ++cp )
665                 if( *cp == '\n' ) ++ret;
666         return ret;
667 }
668
669 char *ScriptLines::get_text_row(int n)
670 {
671         char *cp = text;
672         if( !n ) return cp;
673         for( int i=used; --i>=0; ) {
674                 if( *cp++ != '\n' ) continue;
675                 if( --n <= 0 ) return cp;
676         }
677         return 0;
678 }
679
680 ScriptScroll::ScriptScroll(SWindowGUI *gui, int x, int y, int w)
681  : BC_ScrollBar(x, y, SCROLL_HORIZ + SCROLL_STRETCH, w, 0, 0, 0)
682 {
683         this->sw_gui = gui;
684 }
685
686 ScriptScroll::~ScriptScroll()
687 {
688 }
689
690 int ScriptScroll::handle_event()
691 {
692         int64_t pos = get_value();
693         sw_gui->set_script_pos(pos);
694         sw_gui->script_position->update(pos);
695         return 1;
696 }
697
698
699 ScriptPosition::ScriptPosition(SWindowGUI *gui, int x, int y, int w, int v, int mn, int mx)
700  : BC_TumbleTextBox(gui, v, mn, mx, x, y, w-BC_Tumbler::calculate_w())
701 {
702         this->sw_gui = gui;
703 }
704
705 ScriptPosition::~ScriptPosition()
706 {
707 }
708
709 int ScriptPosition::handle_event()
710 {
711         int64_t pos = atol(get_text());
712         sw_gui->set_script_pos(pos);
713         sw_gui->script_scroll->update_value(pos);
714         return 1;
715 }
716
717
718 ScriptEntry::ScriptEntry(SWindowGUI *gui, int x, int y, int w, int rows, char *text)
719  : BC_ScrollTextBox(gui, x, y, w, rows, text, -strlen(text))
720 {
721         this->sw_gui = gui;
722         this->ttext = text;
723 }
724
725 ScriptEntry::ScriptEntry(SWindowGUI *gui, int x, int y, int w, int rows)
726  : BC_ScrollTextBox(gui, x, y, w, rows,(char*)0, BCTEXTLEN)
727 {
728         this->sw_gui = gui;
729         this->ttext = 0;
730 }
731
732 ScriptEntry::~ScriptEntry()
733 {
734 }
735
736 void ScriptEntry::set_text(char *text, int isz)
737 {
738         if( !text || !*text ) return;
739         if( isz < 0 ) isz = strlen(text)+1;
740         BC_ScrollTextBox::set_text(text, isz);
741         ttext = text;
742 }
743
744 int ScriptEntry::handle_event()
745 {
746         if( sw_gui->get_button_down() &&
747             sw_gui->get_buttonpress() == 1 &&
748             sw_gui->get_triple_click() ) {
749                 int ibeam = get_ibeam_letter(), row = 0;
750                 const char *tp = ttext;
751                 while( *tp && tp-ttext < ibeam ) {
752                         if( *tp++ == '\n' ) ++row;
753                 }
754                 int pos = sw_gui->script_entry_no;
755                 sw_gui->load_selection(pos, row);
756         }
757         return 1;
758 }
759
760 int SWindowGUI::load_script_line(FILE *fp)
761 {
762         char line[8192];
763         for(;;) { // skip blank lines
764                 char *cp = fgets(line,sizeof(line),fp);
765                 if( !cp ) return 1;
766                 ++script_line_no;
767                 while( *cp && isspace(*cp) ) ++cp;
768                 if( *cp ) break;
769         }
770
771         ScriptLines *entry = new ScriptLines();
772         script.append(entry);
773
774         for(;;) { // load non-blank lines
775                 //int len = strlen(line);
776                 //if( line[len-1] == '\n' ) line[len-1] = ' ';
777                 entry->append(line);
778                 char *cp = fgets(line,sizeof(line),fp);
779                 if( !cp ) break;
780                 ++script_line_no;
781                 while( *cp && isspace(*cp) ) ++cp;
782                 if( !*cp ) break;
783         }
784         script_text_lines += entry->break_lines();
785         return 0;
786 }
787
788 void SWindowGUI::load_script()
789 {
790         FILE *fp = fopen(script_path,"r");
791         if( !fp ) {
792                 char string[BCTEXTLEN];
793                 sprintf(string,_("cannot open: \"%s\"\n%s"),script_path,strerror(errno));
794                 MainError::show_error(string);
795                 return;
796         }
797         load_script(fp);
798 }
799
800 void SWindowGUI::load_script(FILE *fp)
801 {
802         script.remove_all_objects();
803         script_line_no = 0;
804         script_text_lines = 0;
805         while( !load_script_line(fp) );
806         char value[64];
807         sprintf(value,"%ld",ftell(fp));
808         script_filesz->update(value);
809         sprintf(value,"%jd",script_line_no);
810         script_lines->update(value);
811         sprintf(value,"%d",script.size());
812         script_entries->update(value);
813         sprintf(value,"%jd",script_text_lines);
814         script_texts->update(value);
815         int hw = script_scroll->get_h();
816         script_scroll->update_length(script.size(), script_entry_no, hw, 0);
817         script_position->update(script_entry_no);
818         script_position->set_boundaries((int64_t)0, (int64_t)script.size()-1);
819
820         fclose(fp);
821 }
822
823 void SWindowGUI::save_spumux_data()
824 {
825         char filename[BCTEXTLEN], track_title[BCTEXTLEN];
826         snprintf(filename,sizeof(filename),"%s",script_path);
827         filename[sizeof(filename)-1] = 0;
828         char *bp = strrchr(filename,'/');
829         if( !bp ) bp = filename; else ++bp;
830         char *ext = strrchr(bp, '.');
831         if( !ext ) ext = bp + strlen(bp);
832         int len = sizeof(filename)-1 - (ext-filename);
833
834         Tracks *tracks = swindow->mwindow->edl->tracks;
835         for( Track *track=tracks->first; track; track=track->next ) {
836                 if( track->data_type != TRACK_SUBTITLE ) continue;
837                 if( !track->record ) continue;
838                 char *cp = track_title;
839                 for( char *bp=track->title; *bp; ++bp,++cp )
840                         *cp = !isalnum(*bp) ? '_' : *bp;
841                 *cp = 0;
842                 snprintf(ext,len,"-%s.udvd",track_title);
843                 FILE *fp = fopen(filename, "w");
844                 if( !fp ) {
845                         eprintf(_("Unable to open %s:\n%m"), filename);
846                         continue;
847                 }
848                 int64_t start = 0;
849                 for( Edit *edit=track->edits->first; edit; edit=edit->next ) {
850                         SEdit *sedit = (SEdit *)edit;
851                         if( sedit->length > 0 ) {
852                                 int64_t end = start + sedit->length;
853                                 char *text = sedit->get_text();
854                                 if( *text ) {
855                                         fprintf(fp, "{%jd}{%jd}%s\n", start, end-1, text);
856                                 }
857                                 start = end;
858                         }
859                 }
860                 fclose(fp);
861         }
862 }
863
864
865
866 SWindow::SWindow(MWindow *mwindow)
867  : Thread(1, 0, 0)
868 {
869         this->mwindow = mwindow;
870         window_lock = new Mutex("SWindow::window_lock");
871         swin_lock = new Condition(0,"SWindow::swin_lock");
872         gui = 0;
873         done = 1;
874         gui_done = 1;
875
876         start();
877 }
878
879 SWindow::~SWindow()
880 {
881         stop();
882         delete gui;
883         delete swin_lock;
884         delete window_lock;
885 }
886
887
888 void SWindow::start()
889 {
890         if( !Thread::running() ) {
891                 done = 0;
892                 Thread::start();
893         }
894 }
895
896 void SWindow::stop()
897 {
898         if( Thread::running() ) {
899                 done = 1;
900                 swin_lock->unlock();
901                 window_lock->lock("SWindow::stop");
902                 if( gui ) gui->stop(1);
903                 window_lock->unlock();
904                 Thread::cancel();
905         }
906         Thread::join();
907 }
908
909 void SWindow::run()
910 {
911         int root_w = mwindow->gui->get_root_w(1);
912         int root_h = mwindow->gui->get_root_h(1);
913
914         while( !done ) {
915                 swin_lock->reset();
916                 swin_lock->lock();
917                 if( done ) break;
918                 int x = mwindow->session->swindow_x;
919                 int y = mwindow->session->swindow_y;
920                 int w = mwindow->session->swindow_w;
921                 int h = mwindow->session->swindow_h;
922                 if( w < 600 ) w = 600;
923                 if( h < 500 ) h = 500;
924                 int scr_x = mwindow->gui->get_screen_x(1, -1);
925                 int scr_w = mwindow->gui->get_screen_w(1, -1);
926                 if( x < scr_x ) x = scr_x;
927                 if( x > scr_x+scr_w ) x = scr_x+scr_w;
928                 if( x+w > root_w ) x = root_w - w;
929                 if( x < 0 ) { x = 0;  w = scr_w; }
930                 if( y+h > root_h ) y = root_h - h;
931                 if( y < 0 ) { y = 0;  h = root_h; }
932                 if( y+h > root_h ) h = root_h-y;
933                 mwindow->session->swindow_x = x;
934                 mwindow->session->swindow_y = y;
935                 mwindow->session->swindow_w = w;
936                 mwindow->session->swindow_h = h;
937
938                 gui_done = 0;
939                 gui = new SWindowGUI(this, x, y, w, h);
940                 gui->lock_window("ChannelInfo::gui_create_objects");
941                 gui->load_defaults();
942                 gui->create_objects();
943                 gui->set_icon(mwindow->theme->get_image("record_icon"));
944                 gui->reposition_window(x, y);
945                 gui->resize_event(w, h);
946                 gui->load();
947                 gui->show_window();
948                 gui->unlock_window();
949
950                 int result = gui->run_window();
951                 if( !result ) {
952                         gui->save_spumux_data();
953                 }
954
955                 window_lock->lock("ChannelInfo::run 1");
956                 gui->save_defaults();
957                 delete gui;  gui = 0;
958                 window_lock->unlock();
959         }
960 }
961
962
963
964
965 void SWindow::run_swin()
966 {
967         window_lock->lock("SWindow::run_swin");
968         if( gui ) {
969                 gui->lock_window("SWindow::run_swin");
970                 gui->raise_window();
971                 gui->unlock_window();
972         }
973         else
974                 swin_lock->unlock();
975         window_lock->unlock();
976 }
977
978 void SWindow::paste_subttl()
979 {
980         window_lock->lock("SWindow::paste_subttl 1");
981         if( gui ) {
982                 gui->lock_window("SWindow::paste_subttl 2");
983                 gui->paste_selection();
984                 gui->unlock_window();
985         }
986         window_lock->unlock();
987 }
988
989 int SWindow::update_selection()
990 {
991         window_lock->lock("SWindow::update_selection 1");
992         if( gui ) {
993                 gui->lock_window("SWindow::update_selection 2");
994                 gui->update_selection();
995                 gui->unlock_window();
996         }
997         window_lock->unlock();
998         return 0;
999 }
1000
1001
1002
1003 SubttlSWin::SubttlSWin(MWindow *mwindow)
1004  : BC_MenuItem(_("SubTitle..."), _("Alt-y"), 'y')
1005 {
1006         set_alt();
1007         this->mwindow = mwindow;
1008 }
1009
1010 SubttlSWin::~SubttlSWin()
1011 {
1012 }
1013
1014 int SubttlSWin::handle_event()
1015 {
1016         mwindow->gui->swindow->run_swin();
1017         return 1;
1018 };
1019