opengl colorspace + BT2020
[goodguy/history.git] / cinelerra-5.1 / guicast / bcfilebox.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 1997-2017 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "bcdelete.h"
23 #include "bcfilebox.h"
24 #include "bclistboxitem.h"
25 #include "bcnewfolder.h"
26 #include "bcpixmap.h"
27 #include "bcrename.h"
28 #include "bcresources.h"
29 #include "bcsignals.h"
30 #include "bctitle.h"
31 #include "clip.h"
32 #include "condition.h"
33 #include "filesystem.h"
34 #include "keys.h"
35 #include "language.h"
36 #include "mutex.h"
37 #include <string.h>
38 #include <sys/stat.h>
39
40
41
42
43
44
45
46 BC_FileBoxRecent::BC_FileBoxRecent(BC_FileBox *filebox, int x, int y)
47  : BC_ListBox(x, y, 250,
48                 filebox->get_text_height(MEDIUMFONT) * FILEBOX_HISTORY_SIZE +
49                 BC_ScrollBar::get_span(SCROLL_HORIZ) +
50                 LISTBOX_MARGIN * 2, LISTBOX_TEXT, &filebox->recent_dirs,
51                 0, 0, 1, 0, 1)
52 {
53         this->filebox = filebox;
54 }
55
56 int BC_FileBoxRecent::handle_event()
57 {
58         BC_ListBoxItem *selection = get_selection(0, 0);
59         if( selection != 0 ) {
60                 char *path = selection->get_text();
61                 filebox->submit_dir(path);
62         }
63         return 1;
64 }
65
66
67
68
69
70
71
72
73
74
75
76 BC_FileBoxListBox::BC_FileBoxListBox(int x, int y, BC_FileBox *filebox)
77  : BC_ListBox(x, y, filebox->get_listbox_w(), filebox->get_listbox_h(y),
78                 filebox->get_display_mode(), filebox->list_column,
79                 filebox->column_titles, filebox->column_width,
80                 filebox->columns, 0, 0,
81                 filebox->select_multiple ? LISTBOX_MULTIPLE : LISTBOX_SINGLE,
82                 ICON_LEFT, 0)
83 {
84         this->filebox = filebox;
85         set_sort_column(filebox->sort_column);
86         set_sort_order(filebox->sort_order);
87         set_allow_drag_column(1);
88 }
89
90 BC_FileBoxListBox::~BC_FileBoxListBox()
91 {
92 }
93
94 int BC_FileBoxListBox::handle_event()
95 {
96         filebox->submit_file(filebox->textbox->get_text());
97         return 1;
98 }
99
100 int BC_FileBoxListBox::selection_changed()
101 {
102         BC_ListBoxItem *item = get_selection(
103                 filebox->column_of_type(FILEBOX_NAME), 0);
104
105         if(item) {
106                 char path[BCTEXTLEN];
107                 strcpy(path, item->get_text());
108                 filebox->textbox->update(path);
109                 filebox->fs->extract_dir(filebox->directory, path);
110                 filebox->fs->extract_name(filebox->filename, path);
111                 filebox->fs->complete_path(path);
112                 strcpy(filebox->current_path, path);
113                 strcpy(filebox->submitted_path, path);
114         }
115         return 1;
116 }
117
118 int BC_FileBoxListBox::column_resize_event()
119 {
120         for(int i = 0; i < filebox->columns; i++)
121                 BC_WindowBase::get_resources()->filebox_columnwidth[i] =
122                         filebox->column_width[i] =
123                         get_column_width(i);
124         return 1;
125 }
126
127 int BC_FileBoxListBox::sort_order_event()
128 {
129         get_resources()->filebox_sortcolumn = filebox->sort_column = get_sort_column();
130         get_resources()->filebox_sortorder = filebox->sort_order = get_sort_order();
131         filebox->refresh(-1);
132         return 1;
133 }
134
135 int BC_FileBoxListBox::move_column_event()
136 {
137         filebox->move_column(get_from_column(), get_to_column());
138         return 1;
139 }
140
141 int BC_FileBoxListBox::evaluate_query(char *string)
142 {
143 // Search name column
144         ArrayList<BC_ListBoxItem*> *column =
145                 &filebox->list_column[filebox->column_of_type(FILEBOX_NAME)];
146 // Get current selection
147         int current_selection = get_selection_number(0, 0);
148
149 // Get best score in remaining items
150         int lowest_score = 0x7fffffff;
151         int best_item = -1;
152         if(current_selection < 0) current_selection = 0;
153 //      for(int i = current_selection + 1; i < column->size(); i++)
154         for(int i = current_selection; i < column->size(); i++)
155         {
156                 int len1 = strlen(string);
157                 int len2 = strlen(column->get(i)->get_text());
158                 int current_score = strncasecmp(string,
159                         column->get(i)->get_text(),
160                         MIN(len1, len2));
161 //printf(" %d i=%d %d %s %s\n", __LINE__, i, current_score, string, column->get(i)->get_text());
162
163                 if(abs(current_score) < lowest_score)
164                 {
165                         lowest_score = abs(current_score);
166                         best_item = i;
167                 }
168         }
169
170
171         return best_item;
172 }
173
174
175
176
177 BC_FileBoxTextBox::BC_FileBoxTextBox(int x, int y, BC_FileBox *filebox)
178  : BC_TextBox(x, y, filebox->get_w() - 20, 1,
179         filebox->want_directory ?  filebox->directory : filebox->filename)
180 {
181         this->filebox = filebox;
182 }
183
184 BC_FileBoxTextBox::~BC_FileBoxTextBox()
185 {
186 }
187
188
189
190
191 int BC_FileBoxTextBox::handle_event()
192 {
193         int result = 0;
194         if(get_keypress() != RETURN)
195         {
196                 result = calculate_suggestions(&filebox->list_column[0]);
197         }
198         return result;
199 }
200
201
202
203
204 BC_FileBoxDirectoryText::BC_FileBoxDirectoryText(int x, int y, BC_FileBox *filebox)
205  : BC_TextBox(x, y, filebox->get_w() - 40, 1, filebox->fs->get_current_dir())
206 {
207         this->filebox = filebox;
208 }
209
210 int BC_FileBoxDirectoryText::handle_event()
211 {
212         const char *path = get_text();
213         if( !filebox->fs->is_dir(path) ) return 0;
214         const char *cp = path;
215         while( *cp ) ++cp;
216         if( cp > path && *--cp != '/' ) return 0;
217         char *file_path = FileSystem::basepath(path);
218         char *dir_path = FileSystem::basepath(filebox->directory);
219         int ret = !strcmp(file_path, dir_path) ? 0 : 1;
220         if( ret ) {
221                 strcpy(filebox->directory, file_path);
222                 filebox->update_history();
223                 filebox->fs->change_dir(file_path);
224                 filebox->refresh(1);
225         }
226         delete [] dir_path;
227         delete [] file_path;
228         return ret;
229 }
230
231
232
233
234
235 BC_FileBoxFilterText::BC_FileBoxFilterText(int x, int y, BC_FileBox *filebox)
236  : BC_TextBox(x, y, filebox->get_w() - 50, 1, filebox->get_resources()->filebox_filter)
237 {
238         this->filebox = filebox;
239 }
240
241 int BC_FileBoxFilterText::handle_event()
242 {
243         filebox->update_filter(get_text());
244         return 1;
245 }
246
247
248
249
250 BC_FileBoxFilterMenu::BC_FileBoxFilterMenu(int x, int y, BC_FileBox *filebox)
251  : BC_ListBox(x,
252         y,
253         filebox->get_w() - 30,
254         120,
255         LISTBOX_TEXT,
256         &filebox->filter_list,
257         0,
258         0,
259         1,
260         0,
261         1)
262 {
263         this->filebox = filebox;
264         set_tooltip(_("Change the filter"));
265 }
266
267 int BC_FileBoxFilterMenu::handle_event()
268 {
269         filebox->filter_text->update(
270                 get_selection(filebox->column_of_type(FILEBOX_NAME), 0)->get_text());
271         filebox->update_filter(
272                 get_selection(filebox->column_of_type(FILEBOX_NAME), 0)->get_text());
273         return 1;
274 }
275
276
277
278
279
280
281
282
283
284
285 BC_FileBoxCancel::BC_FileBoxCancel(BC_FileBox *filebox)
286  : BC_CancelButton(filebox)
287 {
288         this->filebox = filebox;
289         set_tooltip(_("Cancel the operation"));
290 }
291
292 BC_FileBoxCancel::~BC_FileBoxCancel()
293 {
294 }
295
296 int BC_FileBoxCancel::handle_event()
297 {
298 //      filebox->submit_file(filebox->textbox->get_text());
299         filebox->newfolder_thread->interrupt();
300         filebox->set_done(1);
301         return 1;
302 }
303
304
305
306
307
308
309
310 BC_FileBoxUseThis::BC_FileBoxUseThis(BC_FileBox *filebox)
311  : BC_Button(filebox->get_w() / 2 -
312                 BC_WindowBase::get_resources()->usethis_button_images[0]->get_w() / 2,
313         filebox->ok_button->get_y(),
314         BC_WindowBase::get_resources()->usethis_button_images)
315 {
316         this->filebox = filebox;
317         set_tooltip(_("Submit the directory"));
318 }
319
320 BC_FileBoxUseThis::~BC_FileBoxUseThis()
321 {
322 }
323
324 int BC_FileBoxUseThis::handle_event()
325 {
326 // printf("BC_FileBoxUseThis::handle_event %d '%s'\n",
327 // __LINE__,
328 // filebox->textbox->get_text());
329         filebox->submit_file(filebox->textbox->get_text(), 1);
330         return 1;
331 }
332
333
334
335
336
337 BC_FileBoxOK::BC_FileBoxOK(BC_FileBox *filebox)
338  : BC_OKButton(filebox,
339         !filebox->want_directory ?
340                 BC_WindowBase::get_resources()->ok_images :
341                 BC_WindowBase::get_resources()->filebox_descend_images)
342 {
343         this->filebox = filebox;
344         if(filebox->want_directory)
345                 set_tooltip(_("Descend directory"));
346         else
347                 set_tooltip(_("Submit the file"));
348 }
349
350 BC_FileBoxOK::~BC_FileBoxOK()
351 {
352 }
353
354 int BC_FileBoxOK::handle_event()
355 {
356 //printf("BC_FileBoxOK::handle_event %d\n", __LINE__);
357         const char *path = filebox->textbox->get_text();
358         if( *path ) filebox->submit_file(path);
359         return 1;
360 }
361
362
363 BC_FileBoxText::BC_FileBoxText(int x, int y, BC_FileBox *filebox)
364  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_text_images)
365 {
366         this->filebox = filebox;
367         set_tooltip(_("Display text"));
368 }
369 int BC_FileBoxText::handle_event()
370 {
371         filebox->create_listbox(filebox->listbox->get_x(), filebox->listbox->get_y(), LISTBOX_TEXT);
372         filebox->listbox->show_window(1);
373         return 1;
374 }
375
376
377 BC_FileBoxIcons::BC_FileBoxIcons(int x, int y, BC_FileBox *filebox)
378  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_icons_images)
379 {
380         this->filebox = filebox;
381         set_tooltip(_("Display icons"));
382 }
383 int BC_FileBoxIcons::handle_event()
384 {
385         filebox->create_listbox(filebox->listbox->get_x(), filebox->listbox->get_y(), LISTBOX_ICONS);
386         filebox->listbox->show_window(1);
387         return 1;
388 }
389
390
391 BC_FileBoxNewfolder::BC_FileBoxNewfolder(int x, int y, BC_FileBox *filebox)
392  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_newfolder_images)
393 {
394         this->filebox = filebox;
395         set_tooltip(_("Create new folder"));
396 }
397 int BC_FileBoxNewfolder::handle_event()
398 {
399         filebox->newfolder_thread->start_new_folder();
400         return 1;
401 }
402
403
404 BC_FileBoxRename::BC_FileBoxRename(int x, int y, BC_FileBox *filebox)
405  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_rename_images)
406 {
407         this->filebox = filebox;
408         set_tooltip(_("Rename file"));
409 }
410 int BC_FileBoxRename::handle_event()
411 {
412         filebox->rename_thread->start_rename();
413         return 1;
414 }
415
416 BC_FileBoxUpdir::BC_FileBoxUpdir(int x, int y, BC_FileBox *filebox)
417  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_updir_images)
418 {
419         this->filebox = filebox;
420         set_tooltip(_("Up a directory"));
421 }
422 int BC_FileBoxUpdir::handle_event()
423 {
424 // Need a temp so submit_file can expand it
425         sprintf(string, "..");
426         filebox->submit_file(string);
427         return 1;
428 }
429
430 BC_FileBoxDelete::BC_FileBoxDelete(int x, int y, BC_FileBox *filebox)
431  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_delete_images)
432 {
433         this->filebox = filebox;
434         set_tooltip(_("Delete files"));
435 }
436 int BC_FileBoxDelete::handle_event()
437 {
438         filebox->unlock_window();
439         filebox->delete_thread->start();
440         filebox->lock_window("BC_FileBoxDelete::handle_event");
441         return 1;
442 }
443
444 BC_FileBoxReload::BC_FileBoxReload(int x, int y, BC_FileBox *filebox)
445  : BC_Button(x, y, BC_WindowBase::get_resources()->filebox_reload_images)
446 {
447         this->filebox = filebox;
448         set_tooltip(_("Refresh"));
449 }
450 int BC_FileBoxReload::handle_event()
451 {
452         filebox->refresh();
453         return 1;
454 }
455
456
457
458
459
460
461
462
463
464
465 BC_FileBox::BC_FileBox(int x, int y, const char *init_path,
466                 const char *title, const char *caption, int show_all_files,
467                 int want_directory, int multiple_files, int h_padding)
468  : BC_Window(title, x, y,
469         BC_WindowBase::get_resources()->filebox_w,
470         BC_WindowBase::get_resources()->filebox_h,
471         400, 300, 1, 0, 1)
472 {
473         fs = new FileSystem;
474 //      if(want_directory)
475 //      {
476 //              fs->set_want_directory();
477 //              columns = DIRBOX_COLUMNS;
478 //              columns = FILEBOX_COLUMNS;
479 //      }
480 //      else
481         {
482                 columns = FILEBOX_COLUMNS;
483         }
484
485         list_column = new ArrayList<BC_ListBoxItem*>[columns];
486         column_type = new int[columns];
487         column_width = new int[columns];
488
489         filter_text = 0;
490         filter_popup = 0;
491         usethis_button = 0;
492
493         strcpy(this->caption, caption);
494         strcpy(this->current_path, init_path);
495         strcpy(this->submitted_path, init_path);
496         select_multiple = multiple_files;
497         this->want_directory = want_directory;
498         if(show_all_files) fs->set_show_all();
499         fs->complete_path(this->current_path);
500         strcpy(this->submitted_path, this->current_path);
501         fs->extract_dir(directory, this->current_path);
502         fs->extract_name(filename, this->current_path);
503
504 // printf("BC_FileBox::BC_FileBox %d '%s' '%s' '%s'\n",
505 // __LINE__,
506 // this->submitted_path,
507 // directory,
508 // filename);
509
510 //      if(want_directory)
511 //      {
512 //              for(int i = 0; i < columns; i++)
513 //              {
514 //                      column_type[i] = get_resources()->dirbox_columntype[i];
515 //                      column_width[i] = get_resources()->dirbox_columnwidth[i];
516 //                      column_titles[i] = BC_FileBox::columntype_to_text(column_type[i]);
517 //              }
518 //              sort_column = get_resources()->dirbox_sortcolumn;
519 //              sort_order = get_resources()->dirbox_sortorder;
520 //      }
521 //      else
522         {
523                 for(int i = 0; i < columns; i++)
524                 {
525                         column_type[i] = get_resources()->filebox_columntype[i];
526                         column_width[i] = get_resources()->filebox_columnwidth[i];
527                         column_titles[i] = (char*)BC_FileBox::columntype_to_text(column_type[i]);
528                 }
529                 sort_column = get_resources()->filebox_sortcolumn;
530                 sort_order = get_resources()->filebox_sortorder;
531         }
532
533
534
535 // Test if current directory exists
536         if(!fs->is_dir(directory))
537         {
538                 sprintf(directory, "~");
539                 fs->complete_path(directory);
540                 strcpy(current_path,directory);
541                 filename[0] = 0;
542         }
543         fs->set_current_dir(directory);
544
545         if(h_padding == -1)
546         {
547                 h_padding = BC_WindowBase::get_resources()->ok_images[0]->get_h() -
548                         20;
549         }
550         this->h_padding = h_padding;
551         delete_thread = new BC_DeleteThread(this);
552         rename_thread = 0;
553 }
554
555 BC_FileBox::~BC_FileBox()
556 {
557 // this has to be destroyed before tables, because it can call for an update!
558         delete newfolder_thread;
559         delete fs;
560         delete_tables();
561         for(int i = 0; i < TOTAL_ICONS; i++)
562                 delete icons[i];
563         filter_list.remove_all_objects();
564         delete [] list_column;
565         delete [] column_type;
566         delete [] column_width;
567         delete delete_thread;
568         delete rename_thread;
569         recent_dirs.remove_all_objects();
570 }
571
572 void BC_FileBox::create_objects()
573 {
574         int x = 10, y = 10;
575         BC_Resources *resources = BC_WindowBase::get_resources();
576         int directory_title_margin = MAX(20,
577                 resources->filebox_text_images[0]->get_h());
578
579 // Directories aren't filtered in FileSystem so skip this
580         if(!want_directory)
581         {
582                 filter_list.append(new BC_ListBoxItem("*"));
583                 filter_list.append(new BC_ListBoxItem("[*.mkv]"));
584                 filter_list.append(new BC_ListBoxItem("[*.mp4]"));
585                 filter_list.append(new BC_ListBoxItem("[*.mp2][*.mp3][*.wav]"));
586                 filter_list.append(new BC_ListBoxItem("[*.avi][*.mpg][*.m2v][*.m1v][*.mov]"));
587                 filter_list.append(new BC_ListBoxItem("*.xml"));
588                 fs->set_filter(get_resources()->filebox_filter);
589         }
590
591         create_icons();
592         create_tables();
593
594         add_subwindow(ok_button = new BC_FileBoxOK(this));
595         if(want_directory)
596                 add_subwindow(usethis_button = new BC_FileBoxUseThis(this));
597         add_subwindow(cancel_button = new BC_FileBoxCancel(this));
598
599         add_subwindow(new BC_Title(x, y, caption));
600
601         x = get_w() - resources->filebox_icons_images[0]->get_w() - 10;
602
603         add_subwindow(icon_button = new BC_FileBoxIcons(x, y, this));
604         x -= resources->filebox_text_images[0]->get_w() + 5;
605
606         add_subwindow(text_button = new BC_FileBoxText(x, y, this));
607         x -= resources->filebox_newfolder_images[0]->get_w() + 5;
608
609         add_subwindow(folder_button = new BC_FileBoxNewfolder(x, y, this));
610         x -= resources->filebox_delete_images[0]->get_w() + 5;
611
612         add_subwindow(rename_button = new BC_FileBoxRename(x, y, this));
613         x -= resources->filebox_delete_images[0]->get_w() + 5;
614
615         add_subwindow(delete_button = new BC_FileBoxDelete(x, y, this));
616         x -= resources->filebox_reload_images[0]->get_w() + 5;
617
618         add_subwindow(reload_button = new BC_FileBoxReload(x, y, this));
619         x -= resources->filebox_updir_images[0]->get_w() + 5;
620
621         add_subwindow(updir_button = new BC_FileBoxUpdir(x, y, this));
622
623         x = 10;
624         y += directory_title_margin + 3;
625
626         add_subwindow(recent_popup = new BC_FileBoxRecent(this, x, y));
627         add_subwindow(directory_title = new BC_FileBoxDirectoryText(x, y, this));
628         directory_title->reposition_window(x, y, get_w() - recent_popup->get_w() -  20, 1);
629         x += directory_title->get_w() + 8;
630         recent_popup->reposition_window(x, y, directory_title->get_w(), 200);
631
632         x = 10;
633         y += directory_title->get_h() + 5;
634
635         int newest_id = 0, newest = -1;
636         for(int i = 0; i < FILEBOX_HISTORY_SIZE; i++) {
637                 if( !resources->filebox_history[i].path[0] ) continue;
638                 if( resources->filebox_history[i].id > newest_id ) {
639                         newest_id = resources->filebox_history[i].id;
640                         newest = i;
641                 }
642         }
643         if( newest >= 0 ) {
644                 strcpy(directory, resources->filebox_history[newest].path);
645                 fs->change_dir(directory, 0);
646                 strcpy(directory, fs->get_current_dir());
647                 directory_title->update(fs->get_current_dir());
648         }
649         fs->set_sort_order(sort_order);
650         fs->set_sort_field(column_type[sort_column]);
651         fs->update(directory);
652
653 // Create recent dir list
654         create_history();
655         update_history();
656
657         listbox = 0;
658         create_listbox(x, y, get_display_mode());
659         y += listbox->get_h() + 10;
660         add_subwindow(textbox = new BC_FileBoxTextBox(x, y, this));
661         y += textbox->get_h() + 10;
662
663         if(!want_directory) {
664                 add_subwindow(filter_text = new BC_FileBoxFilterText(x, y, this));
665                 add_subwindow(filter_popup =
666                         new BC_FileBoxFilterMenu(x + filter_text->get_w(), y, this));;
667         }
668
669 // listbox has to be active because refresh might be called from newfolder_thread
670         listbox->activate();
671         newfolder_thread = new BC_NewFolderThread(this);
672
673         rename_thread = new BC_RenameThread(this);
674
675         refresh();
676         show_window();
677 }
678
679 int BC_FileBox::get_listbox_w()
680 {
681         return get_w() - 20;
682 }
683
684 int BC_FileBox::get_listbox_h(int y)
685 {
686         int result = get_h() - y - h_padding - 10;
687         if(want_directory)
688                 result -= BC_WindowBase::get_resources()->dirbox_margin;
689         else
690                 result -= BC_WindowBase::get_resources()->filebox_margin;
691
692         return result;
693 }
694
695 int BC_FileBox::create_icons()
696 {
697         for(int i = 0; i < TOTAL_ICONS; i++)
698         {
699                 icons[i] = new BC_Pixmap(this,
700                         BC_WindowBase::get_resources()->type_to_icon[i],
701                         PIXMAP_ALPHA);
702         }
703         return 0;
704 }
705
706 int BC_FileBox::resize_event(int w, int h)
707 {
708         draw_background(0, 0, w, h);
709         flash(0);
710
711 // OK button handles resize event itself
712 //      ok_button->reposition_window(ok_button->get_x(),
713 //              h - (get_h() - ok_button->get_y()));
714 //      cancel_button->reposition_window(w - (get_w() - cancel_button->get_x()),
715 //              h - (get_h() - cancel_button->get_y()));
716         if(usethis_button)
717                 usethis_button->reposition_window(w / 2 - 50,
718                         h - (get_h() - usethis_button->get_y()));
719
720
721         if(filter_popup) filter_popup->reposition_window(w - (get_w() - filter_popup->get_x()),
722                 h - (get_h() - filter_popup->get_y()),
723                 w - 30,
724                 0);
725
726
727         if(filter_text) filter_text->reposition_window(filter_text->get_x(),
728                 h - (get_h() - filter_text->get_y()),
729                 w - (get_w() - filter_text->get_w()),
730                 1);
731         directory_title->reposition_window(
732                 directory_title->get_x(),
733                 directory_title->get_y(),
734                 get_w() - recent_popup->get_w() -  20,
735                 1);
736         recent_popup->reposition_window(
737                 directory_title->get_x() + directory_title->get_w() + 8,
738                 directory_title->get_y(),
739                 directory_title->get_w() + recent_popup->get_w(),
740                 recent_popup->get_h());
741         textbox->reposition_window(textbox->get_x(),
742                 h - (get_h() - textbox->get_y()),
743                 w - (get_w() - textbox->get_w()),
744                 1);
745         listbox->reposition_window(listbox->get_x(),
746                 listbox->get_y(),
747                 w - (get_w() - listbox->get_w()),
748                 h - (get_h() - listbox->get_h()),
749                 0);
750         int dx = w - get_w();
751         icon_button->reposition_window(icon_button->get_x()+dx, icon_button->get_y());
752         text_button->reposition_window(text_button->get_x()+dx, text_button->get_y());
753         folder_button->reposition_window(folder_button->get_x()+dx, folder_button->get_y());
754         rename_button->reposition_window(rename_button->get_x()+dx, rename_button->get_y());
755         reload_button->reposition_window(reload_button->get_x()+dx, reload_button->get_y());
756         delete_button->reposition_window(delete_button->get_x()+dx, delete_button->get_y());
757         updir_button->reposition_window(updir_button->get_x()+dx, updir_button->get_y());
758         set_w(w);  set_h(h);
759         get_resources()->filebox_w = get_w();
760         get_resources()->filebox_h = get_h();
761         flush();
762         return 1;
763 }
764
765 int BC_FileBox::keypress_event()
766 {
767         switch(get_keypress())
768         {
769                 case 'w':
770                         if(ctrl_down()) set_done(1);
771                         return 1;
772                         break;
773         }
774         return 0;
775 }
776
777 int BC_FileBox::close_event()
778 {
779         set_done(1);
780         return 1;
781 }
782
783 int BC_FileBox::handle_event()
784 {
785         return 0;
786 }
787
788 int BC_FileBox::extract_extension(char *out, const char *in)
789 {
790         *out = 0;
791         int i = strlen(in);
792         while( --i>=0 && in[i]!='.' );
793         if( i >= 0 ) strcpy(out, &in[++i]);
794         return 0;
795 }
796
797 int BC_FileBox::create_tables()
798 {
799         delete_tables();
800         char string[BCTEXTLEN];
801         BC_ListBoxItem *new_item;
802
803         fs->set_sort_order(sort_order);
804         fs->set_sort_field(column_type[sort_column]);
805
806         for(int i = 0; i < fs->total_files(); i++)
807         {
808                 FileItem *file_item = fs->get_entry(i);
809                 int is_dir = file_item->is_dir;
810                 BC_Pixmap* icon = get_icon(file_item->name, is_dir);
811
812 // Name entry
813                 new_item = new BC_ListBoxItem(file_item->name,
814                         icon,
815                         is_dir ? get_resources()->directory_color : get_resources()->file_color);
816                 if(is_dir) new_item->set_searchable(0);
817                 list_column[column_of_type(FILEBOX_NAME)].append(new_item);
818
819 // Size entry
820 //              if(!want_directory)
821 //              {
822                         if(!is_dir)
823                         {
824                                 sprintf(string, "%jd", file_item->size);
825                                 new_item = new BC_ListBoxItem(string, get_resources()->file_color);
826                         }
827                         else
828                         {
829                                 new_item = new BC_ListBoxItem("", get_resources()->directory_color);
830                         }
831
832                         list_column[column_of_type(FILEBOX_SIZE)].append(new_item);
833 //              }
834
835 // Date entry
836                 if(!is_dir || 1)
837                 {
838                         static const char *month_text[13] = { "Nul",
839                                 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
840                                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
841                         };
842                         sprintf(string,
843                                 "%s %d, %d",
844                                 month_text[file_item->month],
845                                 file_item->day,
846                                 file_item->year);
847                         new_item = new BC_ListBoxItem(string, get_resources()->file_color);
848                 }
849                 else
850                 {
851                         new_item = new BC_ListBoxItem("", get_resources()->directory_color);
852                 }
853
854                 list_column[column_of_type(FILEBOX_DATE)].append(new_item);
855
856 // Extension entry
857 //              if(!want_directory)
858 //              {
859                         if(!is_dir) {
860                                 extract_extension(string, file_item->name);
861                                 new_item = new BC_ListBoxItem(string, get_resources()->file_color);
862                         }
863                         else {
864                                 new_item = new BC_ListBoxItem("", get_resources()->directory_color);
865                         }
866                         list_column[column_of_type(FILEBOX_EXTENSION)].append(new_item);
867 //              }
868         }
869
870         return 0;
871 }
872
873 int BC_FileBox::delete_tables()
874 {
875         for(int j = 0; j < columns; j++)
876         {
877                 list_column[j].remove_all_objects();
878         }
879         return 0;
880 }
881
882 BC_Pixmap* BC_FileBox::get_icon(char *path, int is_dir)
883 {
884         if( is_dir ) return icons[ICON_FOLDER];
885         int icon_type = ICON_UNKNOWN;
886         char *suffix = strrchr(path, '.');
887         if( suffix && *++suffix ) {
888                 suffix_to_type_t *stp = &BC_WindowBase::get_resources()->suffix_to_type[0];
889                 while( stp->suffix && strcasecmp(stp->suffix, suffix) ) ++stp;
890                 if( stp->icon_type ) icon_type = stp->icon_type;
891         }
892
893         return icons[icon_type];
894 }
895
896 const char* BC_FileBox::columntype_to_text(int type)
897 {
898         switch(type) {
899                 case FILEBOX_NAME: return FILEBOX_NAME_TEXT;
900                 case FILEBOX_SIZE: return FILEBOX_SIZE_TEXT;
901                 case FILEBOX_DATE: return FILEBOX_DATE_TEXT;
902                 case FILEBOX_EXTENSION: return FILEBOX_EXTENSION_TEXT;
903         }
904         return "";
905 }
906
907 int BC_FileBox::column_of_type(int type)
908 {
909         for(int i = 0; i < columns; i++)
910                 if(column_type[i] == type) return i;
911         return 0;
912 }
913
914
915
916 int BC_FileBox::refresh(int reset)
917 {
918         fs->set_sort_order(sort_order);
919         fs->set_sort_field(column_type[sort_column]);
920         if( reset >= 0 )
921                 fs->update(0);
922         else
923                 fs->update_sort();
924         create_tables();
925         listbox->set_master_column(column_of_type(FILEBOX_NAME), 0);
926         listbox->update(list_column, column_titles, column_width, columns,
927                 reset>0 ? 0 : listbox->get_xposition(),
928                 reset>0 ? 0 : listbox->get_yposition(),
929                 -1, 1);
930         return 0;
931 }
932
933 int BC_FileBox::update_filter(const char *filter)
934 {
935         fs->set_filter(filter);
936 //      fs->update(0);
937         refresh();
938         strcpy(get_resources()->filebox_filter, filter);
939
940         return 0;
941 }
942
943
944 void BC_FileBox::move_column(int src, int dst)
945 {
946         if(src != dst)
947         {
948                 ArrayList<BC_ListBoxItem*> *new_columns =
949                         new ArrayList<BC_ListBoxItem*>[columns];
950                 int *new_types = new int[columns];
951                 int *new_widths = new int[columns];
952
953         // Fill in remaining columns with consecutive data
954                 for(int out_column = 0, in_column = 0;
955                         out_column < columns;
956                         out_column++,
957                         in_column++)
958                 {
959         // Copy destination column from src column
960                         if(out_column == dst)
961                         {
962                                 for(int i = 0; i < list_column[src].total; i++)
963                                 {
964                                         new_columns[out_column].append(list_column[src].values[i]);
965                                 }
966                                 new_types[out_column] = column_type[src];
967                                 new_widths[out_column] = column_width[src];
968                                 in_column--;
969                         }
970                         else
971                         {
972         // Skip source column
973                                 if(in_column == src) in_column++;
974                                 for(int i = 0; i < list_column[src].total; i++)
975                                 {
976                                         new_columns[out_column].append(list_column[in_column].values[i]);
977                                 }
978                                 new_types[out_column] = column_type[in_column];
979                                 new_widths[out_column] = column_width[in_column];
980                         }
981                 }
982
983         // Swap tables
984                 delete [] list_column;
985                 delete [] column_type;
986                 delete [] column_width;
987                 list_column = new_columns;
988                 column_type = new_types;
989                 column_width = new_widths;
990
991                 for(int i = 0; i < columns; i++)
992                 {
993                         get_resources()->filebox_columntype[i] = column_type[i];
994                         get_resources()->filebox_columnwidth[i] = column_width[i];
995                         column_titles[i] = (char*)BC_FileBox::columntype_to_text(column_type[i]);
996                 }
997         }
998
999         refresh();
1000 }
1001
1002
1003 int BC_FileBox::submit_dir(char *dir)
1004 {
1005         strcpy(directory, dir);
1006         fs->join_names(current_path, directory, filename);
1007
1008 // printf("BC_FileBox::submit_dir %d '%s' '%s' '%s'\n",
1009 // __LINE__,
1010 // current_path,
1011 // directory,
1012 // filename);
1013         strcpy(submitted_path, current_path);
1014         fs->change_dir(dir, 0);
1015         refresh(1);
1016         directory_title->update(fs->get_current_dir());
1017         if(want_directory)
1018                 textbox->update(fs->get_current_dir());
1019         else
1020                 textbox->update(filename);
1021         listbox->reset_query();
1022         return 0;
1023 }
1024
1025 int BC_FileBox::submit_file(const char *path, int use_this)
1026 {
1027         char path1[BCTEXTLEN];
1028         strcpy(path1, path);
1029         char *cp = strchr(path1,'\n');
1030         if( cp ) *cp = 0;
1031
1032 // Deactivate textbox to hide suggestions
1033         textbox->deactivate();
1034
1035 // If file wanted, take the current directory as the desired file.
1036 // If directory wanted, ignore it.
1037         if(!path1[0] && !want_directory)
1038         {
1039 // save complete path
1040                 strcpy(this->current_path, directory);
1041 // save complete path
1042                 strcpy(this->submitted_path, directory);
1043                 update_history();
1044 // Zero out filename
1045                 filename[0] = 0;
1046                 set_done(0);
1047                 return 0;
1048         }
1049
1050 // is a directory, change directories
1051         if(fs->is_dir(path1) && !use_this)
1052         {
1053                 fs->change_dir(path1, 0);
1054                 refresh(1);
1055                 directory_title->update(fs->get_current_dir());
1056                 strcpy(this->current_path, fs->get_current_dir());
1057                 strcpy(this->submitted_path, fs->get_current_dir());
1058                 strcpy(this->directory, fs->get_current_dir());
1059                 update_history();
1060                 filename[0] = 0;
1061                 if(want_directory)
1062                         textbox->update(fs->get_current_dir());
1063                 else
1064                         textbox->update("");
1065                 listbox->reset_query();
1066                 return 1;
1067         }
1068         else
1069 // Is a file or desired directory.  Quit the operation.
1070         {
1071                 char path2[BCTEXTLEN];
1072                 strcpy(path2, path1);
1073
1074 // save directory for defaults
1075                 fs->extract_dir(directory, path2);
1076
1077 // Just take the directory
1078                 if(want_directory)
1079                 {
1080                         filename[0] = 0;
1081                         strcpy(path2, directory);
1082                 }
1083                 else
1084 // Take the complete path
1085                 {
1086                         fs->extract_name(filename, path2);     // save filename
1087                 }
1088
1089                 fs->complete_path(path2);
1090                 strcpy(this->current_path, path2);          // save complete path
1091                 strcpy(this->submitted_path, path2);          // save complete path
1092                 update_history();
1093                 newfolder_thread->interrupt();
1094                 set_done(0);
1095                 return 0;
1096         }
1097         return 0;
1098 }
1099
1100 void BC_FileBox::update_history()
1101 {
1102 // Look for path already in history
1103         BC_Resources *resources = get_resources();
1104         char path[BCTEXTLEN];
1105         strcpy(path, directory);
1106 // enfore one trailing slash
1107         char *cp = path;
1108         while( *cp && *cp != '\n' ) ++cp;
1109         while( cp > path && *(cp-1) == '/' ) --cp;
1110         *cp++ = '/';  *cp = 0;
1111
1112 //      int new_slot = FILEBOX_HISTORY_SIZE - 1;
1113
1114         for(int i = FILEBOX_HISTORY_SIZE - 1; i >= 0; i--)
1115         {
1116                 if(resources->filebox_history[i].path[0] &&
1117                         !strcmp(resources->filebox_history[i].path, path))
1118                 {
1119 // Got matching path.
1120 // Update ID.
1121                         resources->filebox_history[i].id = resources->get_filebox_id();
1122                         return;
1123                 }
1124 // // Shift down from this point.
1125 //                      while(i > 0)
1126 //                      {
1127 //                              strcpy(resources->filebox_history[i],
1128 //                                      resources->filebox_history[i - 1]);
1129 //                              if(resources->filebox_history[i][0]) new_slot--;
1130 //                              i--;
1131 //                      }
1132 //                      break;
1133 //              }
1134 //              else
1135 //                      if(resources->filebox_history[i][0])
1136 //                              new_slot--;
1137 //              else
1138 //                      break;
1139         }
1140
1141 // Remove oldest entry if full
1142         if(resources->filebox_history[FILEBOX_HISTORY_SIZE - 1].path[0])
1143         {
1144                 int oldest_id = 0x7fffffff;
1145                 int oldest = 0;
1146                 for(int i = 0; i < FILEBOX_HISTORY_SIZE; i++)
1147                 {
1148                         if(resources->filebox_history[i].path[0] &&
1149                                 resources->filebox_history[i].id < oldest_id)
1150                         {
1151                                 oldest_id = resources->filebox_history[i].id;
1152                                 oldest = i;
1153                         }
1154                 }
1155
1156                 for(int i = oldest; i < FILEBOX_HISTORY_SIZE - 1; i++)
1157                 {
1158                         strcpy(resources->filebox_history[i].path,
1159                                 resources->filebox_history[i + 1].path);
1160                         resources->filebox_history[i].id =
1161                                 resources->filebox_history[i + 1].id;
1162                 }
1163         }
1164
1165 // Create new entry
1166         strcpy(resources->filebox_history[FILEBOX_HISTORY_SIZE - 1].path, path);
1167         resources->filebox_history[FILEBOX_HISTORY_SIZE - 1].id = resources->get_filebox_id();
1168
1169 // Alphabetize
1170         int done = 0;
1171         while(!done)
1172         {
1173                 done = 1;
1174                 for(int i = 1; i < FILEBOX_HISTORY_SIZE; i++)
1175                 {
1176                         if( (resources->filebox_history[i - 1].path[0] &&
1177                                 resources->filebox_history[i].path[0] &&
1178                                 strcasecmp(resources->filebox_history[i - 1].path,
1179                                         resources->filebox_history[i].path) > 0) ||
1180                                 (resources->filebox_history[i - 1].path[0] == 0 &&
1181                                         resources->filebox_history[i].path[0]) )
1182                         {
1183                                 done = 0;
1184                                 char temp[BCTEXTLEN];
1185                                 int id_temp;
1186                                 strcpy(temp, resources->filebox_history[i - 1].path);
1187                                 id_temp = resources->filebox_history[i - 1].id;
1188                                 strcpy(resources->filebox_history[i - 1].path,
1189                                         resources->filebox_history[i].path);
1190                                 resources->filebox_history[i - 1].id =
1191                                         resources->filebox_history[i].id;
1192                                 strcpy(resources->filebox_history[i].path, temp);
1193                                 resources->filebox_history[i].id = id_temp;
1194                         }
1195                 }
1196         }
1197
1198 //      if(new_slot < 0)
1199 //      {
1200 //              for(int i = FILEBOX_HISTORY_SIZE - 1; i > 0; i--)
1201 //              {
1202 //                      strcpy(resources->filebox_history[i],
1203 //                                      resources->filebox_history[i - 1]);
1204 //              }
1205 //              new_slot = 0;
1206 //      }
1207 //
1208 //      strcpy(resources->filebox_history[new_slot], path);
1209
1210         create_history();
1211         recent_popup->update(&recent_dirs, 0, 0, 1);
1212 }
1213
1214 void BC_FileBox::create_history()
1215 {
1216         BC_Resources *resources = get_resources();
1217         recent_dirs.remove_all_objects();
1218         for(int i = 0; i < FILEBOX_HISTORY_SIZE; i++) {
1219                 if(resources->filebox_history[i].path[0]) {
1220                         recent_dirs.append(new BC_ListBoxItem(resources->filebox_history[i].path));
1221                 }
1222         }
1223 }
1224
1225
1226 int BC_FileBox::get_display_mode()
1227 {
1228         return top_level->get_resources()->filebox_mode;
1229 }
1230
1231 void BC_FileBox::create_listbox(int x, int y, int mode)
1232 {
1233         if(listbox && listbox->get_display_mode() != mode)
1234         {
1235                 delete listbox;
1236                 listbox = 0;
1237                 top_level->get_resources()->filebox_mode = mode;
1238         }
1239
1240         if(!listbox)
1241                 add_subwindow(listbox = new BC_FileBoxListBox(x, y, this));
1242 }
1243
1244 char* BC_FileBox::get_path(int selection)
1245 {
1246         if(selection == 0)
1247         {
1248                 return get_submitted_path();
1249         }
1250         else
1251         {
1252                 BC_ListBoxItem *item = listbox->get_selection(
1253                         column_of_type(FILEBOX_NAME), selection - 1);
1254                 if(item)
1255                 {
1256                         fs->join_names(string, directory, item->get_text());
1257                         return string;
1258                 }
1259         }
1260         return 0;
1261 }
1262
1263 char* BC_FileBox::get_submitted_path()
1264 {
1265         return submitted_path;
1266 }
1267
1268 char* BC_FileBox::get_current_path()
1269 {
1270 //printf("BC_FileBox::get_current_path 1 %s\n", current_path);
1271         return current_path;
1272 }
1273
1274 char* BC_FileBox::get_newfolder_title()
1275 {
1276         char *letter2 = strchr(title, ':');
1277         new_folder_title[0] = 0;
1278         if(letter2)
1279         {
1280                 memcpy(new_folder_title, title, letter2 - title);
1281                 new_folder_title[letter2 - title] = 0;
1282         }
1283
1284         strcat(new_folder_title, _(": New folder"));
1285
1286         return new_folder_title;
1287 }
1288
1289 char* BC_FileBox::get_rename_title()
1290 {
1291         char *letter2 = strchr(title, ':');
1292         new_folder_title[0] = 0;
1293         if(letter2)
1294         {
1295                 memcpy(new_folder_title, title, letter2 - title);
1296                 new_folder_title[letter2 - title] = 0;
1297         }
1298
1299         strcat(new_folder_title, _(": Rename"));
1300
1301         return new_folder_title;
1302 }
1303
1304 char* BC_FileBox::get_delete_title()
1305 {
1306         char *letter2 = strchr(title, ':');
1307         new_folder_title[0] = 0;
1308         if(letter2)
1309         {
1310                 memcpy(new_folder_title, title, letter2 - title);
1311                 new_folder_title[letter2 - title] = 0;
1312         }
1313
1314         strcat(new_folder_title, _(": Delete"));
1315
1316         return new_folder_title;
1317 }
1318
1319 void BC_FileBox::delete_files()
1320 {
1321 // Starting at 1 causes it to ignore what's in the textbox.
1322         int i = 1;
1323         char *path;
1324         FileSystem fs;
1325         while((path = get_path(i)))
1326         {
1327 // Not directory.  Remove it.
1328                 if(!fs.is_dir(path))
1329                 {
1330 //printf("BC_FileBox::delete_files: removing \"%s\"\n", path);
1331                         remove(path);
1332                 }
1333                 i++;
1334         }
1335         refresh();
1336 }
1337
1338 BC_Button* BC_FileBox::get_ok_button()
1339 {
1340         return ok_button;
1341 }
1342
1343 BC_Button* BC_FileBox::get_cancel_button()
1344 {
1345         return cancel_button;
1346 }
1347