opengl colorspace + BT2020
[goodguy/history.git] / cinelerra-5.1 / cinelerra / awindowgui.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 1997-2012 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 "asset.h"
23 #include "assetedit.h"
24 #include "assetpopup.h"
25 #include "assets.h"
26 #include "awindowgui.h"
27 #include "awindow.h"
28 #include "bccmodels.h"
29 #include "bcsignals.h"
30 #include "bchash.h"
31 #include "cache.h"
32 #include "cstrdup.h"
33 #include "clip.h"
34 #include "clippopup.h"
35 #include "cursors.h"
36 #include "cwindowgui.h"
37 #include "cwindow.h"
38 #include "edl.h"
39 #include "edlsession.h"
40 #include "effectlist.h"
41 #include "file.h"
42 #include "filesystem.h"
43 #include "folderlistmenu.h"
44 #include "indexable.h"
45 #include "keys.h"
46 #include "language.h"
47 #include "labels.h"
48 #include "labelpopup.h"
49 #include "localsession.h"
50 #include "mainmenu.h"
51 #include "mainsession.h"
52 #include "mwindowgui.h"
53 #include "mwindow.h"
54 #include "nestededls.h"
55 #include "newfolder.h"
56 #include "preferences.h"
57 #include "theme.h"
58 #include "vframe.h"
59 #include "vicon.h"
60 #include "vwindowgui.h"
61 #include "vwindow.h"
62
63 #include "data/lad_picon_png.h"
64 #include "data/ff_audio_png.h"
65 #include "data/ff_video_png.h"
66
67 #include<stdio.h>
68 #include<unistd.h>
69 #include<fcntl.h>
70
71
72 const char *AWindowGUI::folder_names[] =
73 {
74         N_("Audio Effects"),
75         N_("Video Effects"),
76         N_("Audio Transitions"),
77         N_("Video Transitions"),
78         N_("Labels"),
79         N_("Clips"),
80         N_("Media"),
81         N_("Proxy"),
82 };
83
84
85 AssetVIcon::AssetVIcon(AssetPicon *picon, int w, int h, double framerate, int64_t length)
86  : VIcon(w, h, framerate)
87 {
88         this->picon = picon;
89         this->length = length;
90         temp = 0;
91 }
92
93 AssetVIcon::~AssetVIcon()
94 {
95         delete temp;
96 }
97
98 VFrame *AssetVIcon::frame()
99 {
100         if( seq_no >= images.size() ) {
101                 MWindow *mwindow = picon->mwindow;
102                 Asset *asset = (Asset *)picon->indexable;
103                 File *file = mwindow->video_cache->check_out(asset, mwindow->edl, 1);
104                 if( !file ) return 0;
105                 if( temp && (temp->get_w() != asset->width || temp->get_h() != asset->height) ) {
106                         delete temp;  temp = 0;
107                 }
108                 if( !temp )
109                         temp = new VFrame(asset->width, asset->height, BC_RGB888, 0);
110                 int ww = picon->gui->vicon_thread->view_w;
111                 int hh = picon->gui->vicon_thread->view_h;
112                 while( seq_no >= images.size() ) {
113                         file->set_layer(0);
114                         int64_t pos = images.size() / picon->gui->vicon_thread->refresh_rate * frame_rate;
115                         file->set_video_position(pos,0);
116                         file->read_frame(temp);
117                         add_image(temp, ww, hh, BC_RGB8);
118                 }
119                 mwindow->video_cache->check_in(asset);
120         }
121         return *images[seq_no];
122 }
123
124 int64_t AssetVIcon::set_seq_no(int64_t no)
125 {
126         if( no >= length ) no = 0;
127         return seq_no = no;
128 }
129
130 int AssetVIcon::get_vx()
131 {
132         BC_ListBox *lbox = picon->gui->asset_list;
133         return lbox->get_item_x(picon);
134 }
135 int AssetVIcon::get_vy()
136 {
137         BC_ListBox *lbox = picon->gui->asset_list;
138         return lbox->get_item_y(picon) + lbox->get_title_h();
139 }
140
141
142 AssetPicon::AssetPicon(MWindow *mwindow,
143         AWindowGUI *gui, Indexable *indexable)
144  : BC_ListBoxItem()
145 {
146         reset();
147         this->mwindow = mwindow;
148         this->gui = gui;
149         this->indexable = indexable;
150         indexable->add_user();
151         this->id = indexable->id;
152 }
153
154 AssetPicon::AssetPicon(MWindow *mwindow,
155         AWindowGUI *gui, EDL *edl)
156  : BC_ListBoxItem()
157 {
158         reset();
159         this->mwindow = mwindow;
160         this->gui = gui;
161         this->edl = edl;
162         edl->add_user();
163         this->id = edl->id;
164 }
165
166 AssetPicon::AssetPicon(MWindow *mwindow,
167         AWindowGUI *gui, int folder, int persist)
168  : BC_ListBoxItem(_(AWindowGUI::folder_names[folder]),
169         folder>=0 && folder<AWINDOW_FOLDERS ?
170                 gui->folder_icons[folder]: gui->folder_icon)
171 {
172         reset();
173         foldernum = folder;
174         this->mwindow = mwindow;
175         this->gui = gui;
176         persistent = persist;
177 }
178
179 AssetPicon::AssetPicon(MWindow *mwindow,
180         AWindowGUI *gui, PluginServer *plugin)
181  : BC_ListBoxItem()
182 {
183         reset();
184         this->mwindow = mwindow;
185         this->gui = gui;
186         this->plugin = plugin;
187 }
188
189 AssetPicon::AssetPicon(MWindow *mwindow,
190         AWindowGUI *gui, Label *label)
191  : BC_ListBoxItem()
192 {
193         reset();
194         this->mwindow = mwindow;
195         this->gui = gui;
196         this->label = label;
197         indexable = 0;
198         icon = 0;
199         id = 0;
200 }
201
202 AssetPicon::~AssetPicon()
203 {
204         if( vicon )
205                 gui->vicon_thread->del_vicon(vicon);
206         if( indexable ) indexable->remove_user();
207         if( edl ) edl->remove_user();
208         if( icon && !gui->protected_pixmap(icon) ) {
209                 delete icon;
210                 if( !plugin ) delete icon_vframe;
211         }
212 }
213
214 void AssetPicon::reset()
215 {
216         plugin = 0;
217         label = 0;
218         indexable = 0;
219         edl = 0;
220         foldernum = AW_NO_FOLDER;
221         icon = 0;
222         icon_vframe = 0;
223         vicon = 0;
224         in_use = 1;
225         id = 0;
226         persistent = 0;
227 }
228
229 void AssetPicon::create_objects()
230 {
231         FileSystem fs;
232         char name[BCTEXTLEN];
233         int pixmap_w, pixmap_h;
234
235         pixmap_h = 50 * BC_WindowBase::get_resources()->icon_scale;
236
237         if( indexable ) {
238                 fs.extract_name(name, indexable->path);
239                 set_text(name);
240         }
241
242         if( indexable && indexable->is_asset ) {
243                 Asset *asset = (Asset*)indexable;
244                 if( asset->video_data ) {
245                         if( mwindow->preferences->use_thumbnails ) {
246                                 gui->unlock_window();
247                                 File *file = mwindow->video_cache->check_out(asset,
248                                         mwindow->edl,
249                                         1);
250
251                                 if( file ) {
252                                         int height = asset->height > 0 ? asset->height : 1;
253                                         pixmap_w = pixmap_h * asset->width / height;
254
255                                         file->set_layer(0);
256                                         file->set_video_position(0, 0);
257
258                                         if( gui->temp_picon &&
259                                                 (gui->temp_picon->get_w() != asset->width ||
260                                                 gui->temp_picon->get_h() != asset->height) ) {
261                                                 delete gui->temp_picon;
262                                                 gui->temp_picon = 0;
263                                         }
264
265                                         if( !gui->temp_picon ) {
266                                                 gui->temp_picon = new VFrame(0, -1,
267                                                         asset->width, asset->height,
268                                                         BC_RGB888, -1);
269                                         }
270                                         { char string[BCTEXTLEN];
271                                         sprintf(string, _("Reading %s"), name);
272                                         mwindow->gui->lock_window("AssetPicon::create_objects");
273                                         mwindow->gui->show_message(string);
274                                         mwindow->gui->unlock_window(); }
275                                         file->read_frame(gui->temp_picon);
276                                         mwindow->video_cache->check_in(asset);
277
278                                         gui->lock_window("AssetPicon::create_objects 1");
279                                         icon = new BC_Pixmap(gui, pixmap_w, pixmap_h);
280                                         icon->draw_vframe(gui->temp_picon,
281                                                 0, 0, pixmap_w, pixmap_h, 0, 0);
282                                         icon_vframe = new VFrame(0,
283                                                 -1, pixmap_w, pixmap_h, BC_RGB888, -1);
284                                         icon_vframe->transfer_from(gui->temp_picon);
285                                         if( asset->awindow_folder == AW_MEDIA_FOLDER ) {
286 // vicon images
287                                                 double framerate = asset->get_frame_rate();
288                                                 if( !framerate ) framerate = VICON_RATE;
289                                                 int64_t frames = asset->get_video_frames();
290                                                 double secs = frames / framerate;
291                                                 if( secs > 5 ) secs = 5;
292                                                 int64_t length = secs * gui->vicon_thread->refresh_rate;
293                                                 vicon = new AssetVIcon(this, pixmap_w, pixmap_h, framerate, length);
294                                                 gui->vicon_thread->add_vicon(vicon);
295                                         }
296
297                                 }
298                                 else {
299                                         gui->lock_window("AssetPicon::create_objects 2");
300                                         icon = gui->video_icon;
301                                         icon_vframe = gui->video_vframe;
302                                 }
303                         }
304                         else {
305                                 icon = gui->video_icon;
306                                 icon_vframe = gui->video_vframe;
307                         }
308                 }
309                 else
310                 if( asset->audio_data ) {
311                         icon = gui->audio_icon;
312                         icon_vframe = gui->audio_vframe;
313                 }
314
315         }
316         else
317         if( indexable && !indexable->is_asset ) {
318                 icon = gui->video_icon;
319                 icon_vframe = gui->video_vframe;
320         }
321         else
322         if( edl ) {
323                 set_text(strcpy(name, edl->local_session->clip_title));
324                 icon = gui->clip_icon;
325                 icon_vframe = gui->clip_vframe;
326         }
327         else
328         if( plugin ) {
329                 strcpy(name,  plugin->title);
330                 set_text(name);
331                 icon_vframe = plugin->get_picon();
332                 if( icon_vframe )
333                         icon = gui->create_pixmap(icon_vframe);
334                 else if( plugin->audio ) {
335                         if( plugin->transition ) {
336                                 icon = gui->atransition_icon;
337                                 icon_vframe = gui->atransition_vframe;
338                         }
339                         else if( plugin->is_ffmpeg() ) {
340                                 icon = gui->ff_aud_icon;
341                                 icon_vframe = gui->ff_aud_vframe;
342                         }
343                         else if( plugin->is_ladspa() ) {
344                                 icon = gui->ladspa_icon;
345                                 icon_vframe = gui->ladspa_vframe;
346                         }
347                         else {
348                                 icon = gui->aeffect_icon;
349                                 icon_vframe = gui->aeffect_vframe;
350                         }
351                 }
352                 else if( plugin->video ) {
353                         if( plugin->transition ) {
354                                 icon = gui->vtransition_icon;
355                                 icon_vframe = gui->vtransition_vframe;
356                         }
357                         else if( plugin->is_ffmpeg() ) {
358                                 icon = gui->ff_vid_icon;
359                                 icon_vframe = gui->ff_vid_vframe;
360                         }
361                         else {
362                                 icon = gui->veffect_icon;
363                                 icon_vframe = gui->veffect_vframe;
364                         }
365                 }
366         }
367         else
368         if( label ) {
369                 Units::totext(name,
370                               label->position,
371                               mwindow->edl->session->time_format,
372                               mwindow->edl->session->sample_rate,
373                               mwindow->edl->session->frame_rate,
374                               mwindow->edl->session->frames_per_foot);
375                 set_text(name);
376                 icon = gui->label_icon;
377                 icon_vframe = gui->label_vframe;
378         }
379         if( !icon ) {
380                 icon = gui->file_icon;
381                 icon_vframe = BC_WindowBase::get_resources()->type_to_icon[ICON_UNKNOWN];
382         }
383         set_icon(icon);
384         set_icon_vframe(icon_vframe);
385 }
386
387 AWindowGUI::AWindowGUI(MWindow *mwindow, AWindow *awindow)
388  : BC_Window(_(PROGRAM_NAME ": Resources"),
389         mwindow->session->awindow_x, mwindow->session->awindow_y,
390         mwindow->session->awindow_w, mwindow->session->awindow_h,
391         100, 100, 1, 1, 1)
392 {
393         this->mwindow = mwindow;
394         this->awindow = awindow;
395
396         file_vframe = 0;                file_icon = 0;
397         folder_vframe = 0;              folder_icon = 0;
398         audio_vframe = 0;               audio_icon = 0;
399         video_vframe = 0;               video_icon = 0;
400         label_vframe = 0;               label_icon = 0;
401
402         atransition_vframe = 0;         atransition_icon = 0;
403         vtransition_vframe = 0;         vtransition_icon = 0;
404         aeffect_vframe = 0;             aeffect_icon = 0;
405         ladspa_vframe = 0;              ladspa_icon = 0;
406         veffect_vframe = 0;             veffect_icon = 0;
407         ff_aud_vframe = 0;              ff_aud_icon = 0;
408         ff_vid_vframe = 0;              ff_vid_icon = 0;
409
410         aeffect_folder_vframe = 0;      aeffect_folder_icon = 0;
411         atransition_folder_vframe = 0;  atransition_folder_icon = 0;
412         clip_folder_vframe = 0;         clip_folder_icon = 0;
413         label_folder_vframe = 0;        label_folder_icon = 0;
414         media_folder_vframe = 0;        media_folder_icon = 0;
415         proxy_folder_vframe = 0;        proxy_folder_icon = 0;
416         veffect_folder_vframe = 0;      veffect_folder_icon = 0;
417         vtransition_folder_vframe = 0;  vtransition_folder_icon = 0;
418
419         ladspa_vframe = 0;              ladspa_icon = 0;
420         ff_aud_vframe = 0;              ff_aud_icon = 0;
421         ff_vid_vframe = 0;              ff_vid_icon = 0;
422
423         clip_vframe = 0;                clip_icon = 0;
424         atransition_vframe = 0;         atransition_icon = 0;
425         vtransition_vframe = 0;         vtransition_icon = 0;
426         aeffect_vframe = 0;             aeffect_icon = 0;
427         veffect_vframe = 0;             veffect_icon = 0;
428
429         plugin_visibility = ((uint64_t)1<<(8*sizeof(uint64_t)-1))-1;
430         newfolder_thread = 0;
431         asset_menu = 0;
432         effectlist_menu = 0;
433         assetlist_menu = 0;
434         cliplist_menu = 0;
435         labellist_menu = 0;
436         folderlist_menu = 0;
437         temp_picon = 0;
438         search_text = 0;
439         allow_iconlisting = 1;
440         remove_plugin = 0;
441         vicon_thread = 0;
442         vicon_drawing = 1;
443         displayed_folder = AW_NO_FOLDER;
444 }
445
446 AWindowGUI::~AWindowGUI()
447 {
448         assets.remove_all_objects();
449         folders.remove_all_objects();
450         aeffects.remove_all_objects();
451         veffects.remove_all_objects();
452         atransitions.remove_all_objects();
453         vtransitions.remove_all_objects();
454         labellist.remove_all_objects();
455         displayed_assets[1].remove_all_objects();
456
457         delete vicon_thread;
458         delete newfolder_thread;
459
460         delete asset_menu;
461         delete clip_menu;
462         delete label_menu;
463         delete effectlist_menu;
464         delete assetlist_menu;
465         delete cliplist_menu;
466         delete labellist_menu;
467         delete folderlist_menu;
468         delete search_text;
469         delete temp_picon;
470         delete remove_plugin;
471
472         delete file_vframe;             delete file_icon;
473         delete folder_vframe;           delete folder_icon;
474         delete audio_vframe;            delete audio_icon;
475         delete video_vframe;            delete video_icon;
476         delete label_vframe;            delete label_icon;
477         delete clip_vframe;             delete clip_icon;
478         delete aeffect_folder_vframe;   delete aeffect_folder_icon;
479         delete atransition_folder_vframe; delete atransition_folder_icon;
480         delete veffect_folder_vframe;   delete veffect_folder_icon;
481         delete vtransition_folder_vframe; delete vtransition_folder_icon;
482         delete clip_folder_vframe;      delete clip_folder_icon;
483         delete label_folder_vframe;     delete label_folder_icon;
484         delete media_folder_vframe;     delete media_folder_icon;
485         delete proxy_folder_vframe;     delete proxy_folder_icon;
486         delete ladspa_vframe;           delete ladspa_icon;
487         delete ff_aud_vframe;           delete ff_aud_icon;
488         delete ff_vid_vframe;           delete ff_vid_icon;
489         delete atransition_vframe;      delete atransition_icon;
490         delete vtransition_vframe;      delete vtransition_icon;
491         delete aeffect_vframe;          delete aeffect_icon;
492         delete veffect_vframe;          delete veffect_icon;
493 }
494
495 bool AWindowGUI::protected_pixmap(BC_Pixmap *icon)
496 {
497         return  icon == file_icon ||
498                 icon == folder_icon ||
499                 icon == audio_icon ||
500                 icon == video_icon ||
501                 icon == clip_icon ||
502                 icon == label_icon ||
503                 icon == vtransition_icon ||
504                 icon == atransition_icon ||
505                 icon == veffect_icon ||
506                 icon == aeffect_icon ||
507                 icon == ladspa_icon ||
508                 icon == ff_aud_icon ||
509                 icon == ff_vid_icon ||
510                 icon == aeffect_folder_icon ||
511                 icon == veffect_folder_icon ||
512                 icon == atransition_folder_icon ||
513                 icon == vtransition_folder_icon ||
514                 icon == label_folder_icon ||
515                 icon == clip_folder_icon ||
516                 icon == media_folder_icon ||
517                 icon == proxy_folder_icon;
518 }
519
520 VFrame *AWindowGUI::get_picon(const char *name, const char *plugin_icons)
521 {
522         char png_path[BCTEXTLEN];
523         char *pp = png_path, *ep = pp + sizeof(png_path)-1;
524         snprintf(pp, ep-pp, "%s/picon/%s/%s.png",
525                 File::get_plugin_path(), plugin_icons, name);
526         if( access(png_path, R_OK) ) return 0;
527         return VFramePng::vframe_png(png_path,0,0);
528 }
529
530 VFrame *AWindowGUI::get_picon(const char *name)
531 {
532         VFrame *vframe = get_picon(name, mwindow->preferences->plugin_icons);
533         if( !vframe ) {
534                 char png_name[BCSTRLEN], *pp = png_name, *ep = pp + sizeof(png_name)-1;
535                 snprintf(pp, ep-pp, "%s.png", name);
536                 unsigned char *data = mwindow->theme->get_image_data(png_name);
537                 if( data ) vframe = new VFramePng(data, 0.);
538         }
539         return vframe;
540 }
541
542 void AWindowGUI::resource_icon(VFrame *&vfrm, BC_Pixmap *&icon, const char *fn, int idx)
543 {
544         vfrm = get_picon(fn);
545         if( !vfrm ) vfrm = BC_WindowBase::get_resources()->type_to_icon[idx];
546         icon = new BC_Pixmap(this, vfrm, PIXMAP_ALPHA);
547 }
548 void AWindowGUI::theme_icon(VFrame *&vfrm, BC_Pixmap *&icon, const char *fn)
549 {
550         vfrm = get_picon(fn);
551         if( !vfrm ) vfrm = mwindow->theme->get_image(fn);
552         icon = new BC_Pixmap(this, vfrm, PIXMAP_ALPHA);
553 }
554 void AWindowGUI::plugin_icon(VFrame *&vfrm, BC_Pixmap *&icon, const char *fn, unsigned char *png)
555 {
556         vfrm = get_picon(fn);
557         if( !vfrm ) vfrm = new VFramePng(png);
558         icon = new BC_Pixmap(this, vfrm, PIXMAP_ALPHA);
559 }
560
561 void AWindowGUI::create_objects()
562 {
563         lock_window("AWindowGUI::create_objects");
564         asset_titles[0] = C_("Title");
565         asset_titles[1] = _("Comments");
566
567         set_icon(mwindow->theme->get_image("awindow_icon"));
568
569         resource_icon(file_vframe,   file_icon,   "film_icon",   ICON_UNKNOWN);
570         resource_icon(folder_vframe, folder_icon, "folder_icon", ICON_FOLDER);
571         resource_icon(audio_vframe,  audio_icon,  "audio_icon",  ICON_SOUND);
572         resource_icon(video_vframe,  video_icon,  "video_icon",  ICON_FILM);
573         resource_icon(label_vframe,  label_icon,  "label_icon",  ICON_LABEL);
574
575         theme_icon(aeffect_folder_vframe,      aeffect_folder_icon,     "aeffect_folder");
576         theme_icon(atransition_folder_vframe,  atransition_folder_icon, "atransition_folder");
577         theme_icon(clip_folder_vframe,         clip_folder_icon,        "clip_folder");
578         theme_icon(label_folder_vframe,        label_folder_icon,       "label_folder");
579         theme_icon(media_folder_vframe,        media_folder_icon,       "media_folder");
580         theme_icon(proxy_folder_vframe,        proxy_folder_icon,       "proxy_folder");
581         theme_icon(veffect_folder_vframe,      veffect_folder_icon,     "veffect_folder");
582         theme_icon(vtransition_folder_vframe,  vtransition_folder_icon, "vtransition_folder");
583
584         folder_icons[AW_AEFFECT_FOLDER] = aeffect_folder_icon;
585         folder_icons[AW_VEFFECT_FOLDER] = veffect_folder_icon;
586         folder_icons[AW_ATRANSITION_FOLDER] = atransition_folder_icon;
587         folder_icons[AW_VTRANSITION_FOLDER] = vtransition_folder_icon;
588         folder_icons[AW_LABEL_FOLDER] = label_folder_icon;
589         folder_icons[AW_CLIP_FOLDER] = clip_folder_icon;
590         folder_icons[AW_MEDIA_FOLDER] = media_folder_icon;
591         folder_icons[AW_PROXY_FOLDER] = proxy_folder_icon;
592
593         theme_icon(clip_vframe,        clip_icon,        "clip_icon");
594         theme_icon(atransition_vframe, atransition_icon, "atransition_icon");
595         theme_icon(vtransition_vframe, vtransition_icon, "vtransition_icon");
596         theme_icon(aeffect_vframe,     aeffect_icon,     "aeffect_icon");
597         theme_icon(veffect_vframe,     veffect_icon,     "veffect_icon");
598
599         plugin_icon(ladspa_vframe, ladspa_icon, "lad_picon", lad_picon_png);
600         plugin_icon(ff_aud_vframe, ff_aud_icon, "ff_audio",  ff_audio_png);
601         plugin_icon(ff_vid_vframe, ff_vid_icon, "ff_video",  ff_video_png);
602
603 // Mandatory folders
604         folders.append(new AssetPicon(mwindow, this, AW_AEFFECT_FOLDER, 1));
605         folders.append(new AssetPicon(mwindow, this, AW_VEFFECT_FOLDER, 1));
606         folders.append(new AssetPicon(mwindow, this, AW_ATRANSITION_FOLDER, 1));
607         folders.append(new AssetPicon(mwindow, this, AW_VTRANSITION_FOLDER, 1));
608         folders.append(new AssetPicon(mwindow, this, AW_LABEL_FOLDER, 1));
609         folders.append(new AssetPicon(mwindow, this, AW_CLIP_FOLDER, 1));
610         folders.append(new AssetPicon(mwindow, this, AW_PROXY_FOLDER, 1));
611         folders.append(new AssetPicon(mwindow, this, AW_MEDIA_FOLDER, 1));
612
613         create_label_folder();
614
615         mwindow->theme->get_awindow_sizes(this);
616         load_defaults(mwindow->defaults);
617
618         int x1 = mwindow->theme->alist_x, y1 = mwindow->theme->alist_y;
619         int w1 = mwindow->theme->alist_w, h1 = mwindow->theme->alist_h;
620         search_text = new AWindowSearchText(mwindow, this, x1, y1+5);
621         search_text->create_objects();
622         int dy = search_text->get_h() + 10;
623         y1 += dy;  h1 -= dy;
624         add_subwindow(asset_list = new AWindowAssets(mwindow, this, x1, y1, w1, h1));
625
626         vicon_thread = new VIconThread(asset_list);
627         vicon_thread->start();
628
629         add_subwindow(divider = new AWindowDivider(mwindow, this,
630                 mwindow->theme->adivider_x, mwindow->theme->adivider_y,
631                 mwindow->theme->adivider_w, mwindow->theme->adivider_h));
632
633         divider->set_cursor(HSEPARATE_CURSOR, 0, 0);
634
635         int fx = mwindow->theme->afolders_x, fy = mwindow->theme->afolders_y;
636         int fw = mwindow->theme->afolders_w, fh = mwindow->theme->afolders_h;
637         VFrame **images = mwindow->theme->get_image_set("playpatch_data");
638         AVIconDrawing::calculate_geometry(this, images, &avicon_w, &avicon_h);
639         add_subwindow(avicon_drawing = new AVIconDrawing(this, fw-avicon_w, fy, images));
640         add_subwindow(add_tools = new AddTools(mwindow, this, fx, fy, _("Visibility")));
641         add_tools->create_objects();
642         fy += add_tools->get_h();  fh -= add_tools->get_h();
643         add_subwindow(folder_list = new AWindowFolders(mwindow,
644                 this, fx, fy, fw, fh));
645         update_effects();
646
647         //int x = mwindow->theme->abuttons_x;
648         //int y = mwindow->theme->abuttons_y;
649
650
651         newfolder_thread = new NewFolderThread(mwindow, this);
652
653         add_subwindow(asset_menu = new AssetPopup(mwindow, this));
654         asset_menu->create_objects();
655         add_subwindow(clip_menu = new ClipPopup(mwindow, this));
656         clip_menu->create_objects();
657         add_subwindow(label_menu = new LabelPopup(mwindow, this));
658         label_menu->create_objects();
659
660         add_subwindow(effectlist_menu = new EffectListMenu(mwindow, this));
661         effectlist_menu->create_objects();
662         add_subwindow(assetlist_menu = new AssetListMenu(mwindow, this));
663         assetlist_menu->create_objects();
664         add_subwindow(cliplist_menu = new ClipListMenu(mwindow, this));
665         cliplist_menu->create_objects();
666         add_subwindow(labellist_menu = new LabelListMenu(mwindow, this));
667         labellist_menu->create_objects();
668
669         add_subwindow(folderlist_menu = new FolderListMenu(mwindow, this));
670         folderlist_menu->create_objects();
671
672         create_custom_xatoms();
673         unlock_window();
674 }
675
676 int AWindowGUI::resize_event(int w, int h)
677 {
678         mwindow->session->awindow_x = get_x();
679         mwindow->session->awindow_y = get_y();
680         mwindow->session->awindow_w = w;
681         mwindow->session->awindow_h = h;
682
683         mwindow->theme->get_awindow_sizes(this);
684         mwindow->theme->draw_awindow_bg(this);
685         reposition_objects();
686
687 //      int x = mwindow->theme->abuttons_x;
688 //      int y = mwindow->theme->abuttons_y;
689 //      new_bin->reposition_window(x, y);
690 //      x += new_bin->get_w();
691 //      delete_bin->reposition_window(x, y);
692 //      x += delete_bin->get_w();
693 //      rename_bin->reposition_window(x, y);
694 //      x += rename_bin->get_w();
695 //      delete_disk->reposition_window(x, y);
696 //      x += delete_disk->get_w();
697 //      delete_project->reposition_window(x, y);
698 //      x += delete_project->get_w();
699 //      info->reposition_window(x, y);
700 //      x += info->get_w();
701 //      redraw_index->reposition_window(x, y);
702 //      x += redraw_index->get_w();
703 //      paste->reposition_window(x, y);
704 //      x += paste->get_w();
705 //      append->reposition_window(x, y);
706 //      x += append->get_w();
707 //      view->reposition_window(x, y);
708
709         BC_WindowBase::resize_event(w, h);
710         return 1;
711 }
712
713 int AWindowGUI::translation_event()
714 {
715         mwindow->session->awindow_x = get_x();
716         mwindow->session->awindow_y = get_y();
717         return 0;
718 }
719
720 void AWindowGUI::reposition_objects()
721 {
722         int x1 = mwindow->theme->alist_x, y1 = mwindow->theme->alist_y;
723         int w1 = mwindow->theme->alist_w, h1 = mwindow->theme->alist_h;
724         search_text->reposition_window(x1, y1+5, w1);
725         int dy = search_text->get_h() + 10;
726         y1 += dy;  h1 -= dy;
727         asset_list->reposition_window(x1, y1, w1, h1);
728         divider->reposition_window(
729                 mwindow->theme->adivider_x, mwindow->theme->adivider_y,
730                 mwindow->theme->adivider_w, mwindow->theme->adivider_h);
731         int fx = mwindow->theme->afolders_x, fy = mwindow->theme->afolders_y;
732         int fw = mwindow->theme->afolders_w, fh = mwindow->theme->afolders_h;
733         add_tools->resize_event(fw-avicon_w, add_tools->get_h());
734         avicon_drawing->reposition_window(fw-avicon_w, fy);
735         fy += add_tools->get_h();  fh -= add_tools->get_h();
736         folder_list->reposition_window(fx, fy, fw, fh);
737 }
738
739 int AWindowGUI::save_defaults(BC_Hash *defaults)
740 {
741         defaults->update("PLUGIN_VISIBILTY", plugin_visibility);
742         defaults->update("VICON_DRAWING", vicon_drawing);
743         return 0;
744 }
745
746 int AWindowGUI::load_defaults(BC_Hash *defaults)
747 {
748         plugin_visibility = defaults->get("PLUGIN_VISIBILTY", plugin_visibility);
749         vicon_drawing = defaults->get("VICON_DRAWING", vicon_drawing);
750         return 0;
751 }
752
753 int AWindowGUI::close_event()
754 {
755         hide_window();
756         mwindow->session->show_awindow = 0;
757         unlock_window();
758
759         mwindow->gui->lock_window("AWindowGUI::close_event");
760         mwindow->gui->mainmenu->show_awindow->set_checked(0);
761         mwindow->gui->unlock_window();
762
763         lock_window("AWindowGUI::close_event");
764         save_defaults(mwindow->defaults);
765         mwindow->save_defaults();
766         return 1;
767 }
768
769 void AWindowGUI::start_vicon_drawing()
770 {
771         if( !vicon_drawing ) return;
772         if( mwindow->edl->session->awindow_folder != AW_MEDIA_FOLDER ) return;
773         if( mwindow->edl->session->assetlist_format != ASSETS_ICONS ) return;
774         vicon_thread->start_drawing();
775 }
776
777 void AWindowGUI::stop_vicon_drawing()
778 {
779         vicon_thread->stop_drawing();
780 }
781
782 AWindowRemovePluginGUI::
783 AWindowRemovePluginGUI(AWindow *awindow, AWindowRemovePlugin *thread,
784         int x, int y, PluginServer *plugin)
785  : BC_Window(_(PROGRAM_NAME ": Remove plugin"), x,y, 500,200, 50, 50, 1, 0, 1, -1, "", 1)
786 {
787         this->awindow = awindow;
788         this->thread = thread;
789         this->plugin = plugin;
790         VFrame *vframe = plugin->get_picon();
791         icon = vframe ? create_pixmap(vframe) : 0;
792         plugin_list.append(new BC_ListBoxItem(plugin->title, icon));
793 }
794
795 AWindowRemovePluginGUI::
796 ~AWindowRemovePluginGUI()
797 {
798         if( !awindow->gui->protected_pixmap(icon) )
799                 delete icon;
800         plugin_list.remove_all();
801 }
802
803 void AWindowRemovePluginGUI::create_objects()
804 {
805         BC_Button *ok_button = new BC_OKButton(this);
806         add_subwindow(ok_button);
807         BC_Button *cancel_button = new BC_CancelButton(this);
808         add_subwindow(cancel_button);
809         int x = 10, y = 10;
810         BC_Title *title = new BC_Title(x, y, _("remove plugin?"));
811         add_subwindow(title);
812         y += title->get_h() + 5;
813         list = new BC_ListBox(x, y,
814                 get_w() - 20, ok_button->get_y() - y - 5, LISTBOX_TEXT, &plugin_list,
815                 0, 0, 1, 0, 0, LISTBOX_SINGLE, ICON_LEFT, 0);
816         add_subwindow(list);
817         show_window();
818 }
819
820 int AWindowRemovePlugin::remove_plugin(PluginServer *plugin, ArrayList<BC_ListBoxItem*> &folder)
821 {
822         int ret = 0;
823         for( int i=0; i<folder.size(); ) {
824                 AssetPicon *picon = (AssetPicon *)folder[i];
825                 if( picon->plugin == plugin ) {
826                         folder.remove_object_number(i);
827                         ++ret;
828                         continue;
829                 }
830                 ++i;
831         }
832         return ret;
833 }
834
835 void AWindowRemovePlugin::handle_close_event(int result)
836 {
837         if( !result ) {
838                 printf(_("remove %s\n"), plugin->path);
839                 awindow->gui->lock_window("AWindowRemovePlugin::handle_close_event");
840                 ArrayList<BC_ListBoxItem*> *folder =
841                         plugin->audio ? plugin->transition ?
842                                 &awindow->gui->atransitions :
843                                 &awindow->gui->aeffects :
844                         plugin->video ?  plugin->transition ?
845                                 &awindow->gui->vtransitions :
846                                 &awindow->gui->veffects :
847                         0;
848                 if( folder ) remove_plugin(plugin, *folder);
849                 MWindow *mwindow = awindow->mwindow;
850                 awindow->gui->unlock_window();
851                 char plugin_path[BCTEXTLEN];
852                 strcpy(plugin_path, plugin->path);
853                 mwindow->plugindb->remove(plugin);
854                 remove(plugin_path);
855                 char index_path[BCTEXTLEN];
856                 mwindow->create_defaults_path(index_path, PLUGIN_FILE);
857                 remove(index_path);
858                 char picon_path[BCTEXTLEN];
859                 FileSystem fs;
860                 snprintf(picon_path, sizeof(picon_path), "%s/picon",
861                         File::get_plugin_path());
862                 char png_name[BCSTRLEN], png_path[BCTEXTLEN];
863                 plugin->get_plugin_png_name(png_name);
864                 fs.update(picon_path);
865                 for( int i=0; i<fs.dir_list.total; ++i ) {
866                         char *fs_path = fs.dir_list[i]->path;
867                         if( !fs.is_dir(fs_path) ) continue;
868                         snprintf(png_path, sizeof(picon_path), "%s/%s",
869                                 fs_path, png_name);
870                         remove(png_path);
871                 }
872                 delete plugin;  plugin = 0;
873                 awindow->gui->async_update_assets();
874         }
875 }
876
877 AWindowRemovePlugin::
878 AWindowRemovePlugin(AWindow *awindow, PluginServer *plugin)
879  : BC_DialogThread()
880 {
881         this->awindow = awindow;
882         this->plugin = plugin;
883 }
884
885 AWindowRemovePlugin::
886 ~AWindowRemovePlugin()
887 {
888         close_window();
889 }
890
891 BC_Window* AWindowRemovePlugin::new_gui()
892 {
893         int x = awindow->gui->get_abs_cursor_x(0);
894         int y = awindow->gui->get_abs_cursor_y(0);
895         AWindowRemovePluginGUI *gui = new AWindowRemovePluginGUI(awindow, this, x, y, plugin);
896         gui->create_objects();
897         return gui;
898 }
899
900 int AWindowGUI::keypress_event()
901 {
902         switch( get_keypress() ) {
903         case 'w': case 'W':
904                 if( ctrl_down() ) {
905                         close_event();
906                         return 1;
907                 }
908                 break;
909         case DELETE:
910                 if( shift_down() ) {
911                         PluginServer* plugin = selected_plugin();
912                         if( !plugin ) break;
913                         remove_plugin = new AWindowRemovePlugin(awindow, plugin);
914                         unlock_window();
915                         remove_plugin->start();
916                         lock_window();
917                 }
918         }
919         return 0;
920 }
921
922
923
924 int AWindowGUI::create_custom_xatoms()
925 {
926         UpdateAssetsXAtom = create_xatom("CWINDOWGUI_UPDATE_ASSETS");
927         return 0;
928 }
929 int AWindowGUI::recieve_custom_xatoms(xatom_event *event)
930 {
931         if( event->message_type == UpdateAssetsXAtom ) {
932                 update_assets();
933                 return 1;
934         }
935         return 0;
936 }
937
938 void AWindowGUI::async_update_assets()
939 {
940         xatom_event event;
941         event.message_type = UpdateAssetsXAtom;
942         send_custom_xatom(&event);
943 }
944
945
946 void AWindowGUI::update_folder_list()
947 {
948         for( int i = 0; i < folders.total; i++ ) {
949                 AssetPicon *picon = (AssetPicon*)folders.values[i];
950                 picon->in_use = 0;
951         }
952
953 // Search assets for folders
954         for( int i = 0; i < mwindow->edl->folders.total; i++ ) {
955                 const char *folder = mwindow->edl->folders.values[i];
956                 int exists = 0;
957
958                 for( int j = 0; j < folders.total; j++ ) {
959                         AssetPicon *picon = (AssetPicon*)folders.values[j];
960                         if( !strcasecmp(picon->get_text(), folder) ) {
961                                 exists = 1;
962                                 picon->in_use = 1;
963                                 break;
964                         }
965                 }
966
967                 if( !exists ) {
968                         int aw_folder = folder_number(folder);
969                         if( aw_folder >= 0 ) {
970                                 AssetPicon *picon = new AssetPicon(mwindow, this, aw_folder, 1);
971                                 picon->create_objects();
972                                 folders.append(picon);
973                         }
974                 }
975         }
976
977 // Delete unused non-persistent folders
978         for( int i=folders.total; --i>=0; ) {
979                 AssetPicon *picon = (AssetPicon*)folders.values[i];
980                 if( !picon->in_use && !picon->persistent ) {
981                         delete picon;
982                         folders.remove_number(i);
983                 }
984         }
985 }
986
987 void AWindowGUI::create_persistent_folder(ArrayList<BC_ListBoxItem*> *output,
988         int do_audio, int do_video, int is_realtime, int is_transition)
989 {
990         ArrayList<PluginServer*> plugin_list;
991 // Get pointers to plugindb entries
992         mwindow->search_plugindb(do_audio, do_video, is_realtime, is_transition,
993                         0, plugin_list);
994
995         for( int i = 0; i < plugin_list.total; i++ ) {
996                 PluginServer *server = plugin_list.values[i];
997                 int visible = plugin_visibility & (1<<server->dir_idx);
998                 if( !visible ) continue;
999 // Create new listitem
1000                 AssetPicon *picon = new AssetPicon(mwindow, this, server);
1001                 picon->create_objects();
1002                 output->append(picon);
1003         }
1004 }
1005
1006 void AWindowGUI::create_label_folder()
1007 {
1008         Label *current;
1009         for( current = mwindow->edl->labels->first; current; current = NEXT ) {
1010                 AssetPicon *picon = new AssetPicon(mwindow, this, current);
1011                 picon->create_objects();
1012                 labellist.append(picon);
1013         }
1014 }
1015
1016
1017 void AWindowGUI::update_asset_list()
1018 {
1019         for( int i = 0; i < assets.total; i++ ) {
1020                 AssetPicon *picon = (AssetPicon*)assets.values[i];
1021                 picon->in_use = 0;
1022         }
1023
1024 // Synchronize EDL clips
1025         for( int i = 0; i < mwindow->edl->clips.total; i++ ) {
1026                 int exists = 0;
1027
1028 // Look for clip in existing listitems
1029                 for( int j = 0; j < assets.total && !exists; j++ ) {
1030                         AssetPicon *picon = (AssetPicon*)assets.values[j];
1031
1032                         if( picon->id == mwindow->edl->clips.values[i]->id ) {
1033                                 picon->edl = mwindow->edl->clips.values[i];
1034                                 picon->set_text(mwindow->edl->clips.values[i]->local_session->clip_title);
1035                                 exists = 1;
1036                                 picon->in_use = 1;
1037                         }
1038                 }
1039
1040 // Create new listitem
1041                 if( !exists ) {
1042                         AssetPicon *picon = new AssetPicon(mwindow,
1043                                 this, mwindow->edl->clips.values[i]);
1044                         picon->create_objects();
1045                         assets.append(picon);
1046                 }
1047         }
1048
1049 // Synchronize EDL assets
1050         for( Asset *current = mwindow->edl->assets->first;
1051                 current;
1052                 current = NEXT ) {
1053                 int exists = 0;
1054
1055 // Look for asset in existing listitems
1056                 for( int j = 0; j < assets.total && !exists; j++ ) {
1057                         AssetPicon *picon = (AssetPicon*)assets.values[j];
1058
1059                         if( picon->id == current->id ) {
1060                                 picon->indexable = current;
1061                                 exists = 1;
1062                                 picon->in_use = 1;
1063                                 break;
1064                         }
1065                 }
1066
1067 // Create new listitem
1068                 if( !exists ) {
1069                         AssetPicon *picon = new AssetPicon(mwindow,
1070                                 this, current);
1071                         picon->create_objects();
1072                         assets.append(picon);
1073                 }
1074         }
1075
1076         mwindow->gui->lock_window("AWindowGUI::update_asset_list");
1077         mwindow->gui->default_message();
1078         mwindow->gui->unlock_window();
1079
1080 // Synchronize nested EDLs
1081         for( int i = 0; i < mwindow->edl->nested_edls->size(); i++ ) {
1082                 int exists = 0;
1083                 Indexable *indexable = mwindow->edl->nested_edls->get(i);
1084
1085 // Look for asset in existing listitems
1086                 for( int j = 0; j < assets.total && !exists; j++ ) {
1087                         AssetPicon *picon = (AssetPicon*)assets.values[j];
1088
1089                         if( picon->id == indexable->id ) {
1090                                 picon->indexable = indexable;
1091                                 exists = 1;
1092                                 picon->in_use = 1;
1093                                 break;
1094                         }
1095                 }
1096
1097 // Create new listitem
1098                 if( !exists ) {
1099                         AssetPicon *picon = new AssetPicon(mwindow,
1100                                 this, indexable);
1101                         picon->create_objects();
1102                         assets.append(picon);
1103                 }
1104         }
1105
1106         for( int i = assets.size() - 1; i >= 0; i-- ) {
1107                 AssetPicon *picon = (AssetPicon*)assets.get(i);
1108                 if( !picon->in_use ) {
1109                         delete picon;
1110                         assets.remove_number(i);
1111                 }
1112         }
1113 }
1114
1115 void AWindowGUI::update_picon(Indexable *indexable)
1116 {
1117         VIcon *vicon = 0;
1118         for( int i = 0; i < assets.total; i++ ) {
1119                 AssetPicon *picon = (AssetPicon*)assets.values[i];
1120                 if( picon->indexable == indexable ||
1121                     picon->edl == (EDL *)indexable ) {
1122                         char name[BCTEXTLEN];
1123                         FileSystem fs;
1124                         fs.extract_name(name, indexable->path);
1125                         picon->set_text(name);
1126                         vicon = picon->vicon;
1127                         break;
1128                 }
1129         }
1130         if( vicon ) {
1131                 stop_vicon_drawing();
1132                 vicon->clear_images();
1133                 vicon->reset(indexable->get_frame_rate());
1134                 start_vicon_drawing();
1135         }
1136 }
1137
1138 void AWindowGUI::sort_assets()
1139 {
1140         switch( mwindow->edl->session->awindow_folder ) {
1141         case AW_AEFFECT_FOLDER:
1142                 sort_picons(&aeffects);
1143                 break;
1144         case AW_VEFFECT_FOLDER:
1145                 sort_picons(&veffects);
1146                 break;
1147         case AW_ATRANSITION_FOLDER:
1148                 sort_picons(&atransitions);
1149                 break;
1150         case AW_VTRANSITION_FOLDER:
1151                 sort_picons(&vtransitions);
1152                 break;
1153         case AW_LABEL_FOLDER:
1154                 sort_picons(&labellist);
1155                 break;
1156         default:
1157                 sort_picons(&assets);
1158         }
1159 // reset xyposition
1160         asset_list->update_format(asset_list->get_format(), 0);
1161         update_assets();
1162 }
1163
1164 void AWindowGUI::sort_folders()
1165 {
1166         sort_picons(&folders);
1167         folder_list->update_format(folder_list->get_format(), 0);
1168         update_assets();
1169 }
1170
1171 void AWindowGUI::collect_assets()
1172 {
1173         int i = 0;
1174         mwindow->session->drag_assets->remove_all();
1175         mwindow->session->drag_clips->remove_all();
1176         while(1)
1177         {
1178                 AssetPicon *result = (AssetPicon*)asset_list->get_selection(0, i++);
1179                 if( !result ) break;
1180
1181                 if( result->indexable ) mwindow->session->drag_assets->append(result->indexable);
1182                 if( result->edl ) mwindow->session->drag_clips->append(result->edl);
1183         }
1184 }
1185
1186 void AWindowGUI::copy_picons(ArrayList<BC_ListBoxItem*> *dst,
1187         ArrayList<BC_ListBoxItem*> *src, int folder)
1188 {
1189 // Remove current pointers
1190         dst[0].remove_all();
1191         dst[1].remove_all_objects();
1192
1193 // Create new pointers
1194         for( int i = 0; i < src->total; i++ ) {
1195                 AssetPicon *picon = (AssetPicon*)src->values[i];
1196                 if( folder < 0 ||
1197                     (picon->indexable && picon->indexable->awindow_folder == folder) ||
1198                     (picon->edl && picon->edl->local_session->awindow_folder == folder) ) {
1199                         const char *text = search_text->get_text();
1200                         int hidden = text && text[0] && !bstrcasestr(picon->get_text(), text);
1201                         if( picon->vicon ) picon->vicon->hidden = hidden;
1202                         if( hidden ) continue;
1203                         BC_ListBoxItem *item2, *item1;
1204                         dst[0].append(item1 = picon);
1205                         if( picon->edl )
1206                                 dst[1].append(item2 = new BC_ListBoxItem(picon->edl->local_session->clip_notes));
1207                         else
1208                         if( picon->label && picon->label->textstr )
1209                                 dst[1].append(item2 = new BC_ListBoxItem(picon->label->textstr));
1210                         else
1211                                 dst[1].append(item2 = new BC_ListBoxItem(""));
1212                         item1->set_autoplace_text(1);  item1->set_autoplace_icon(1);
1213                         item2->set_autoplace_text(1);  item2->set_autoplace_icon(1);
1214                 }
1215         }
1216 }
1217
1218 void AWindowGUI::sort_picons(ArrayList<BC_ListBoxItem*> *src)
1219 {
1220         int done = 0;
1221         while(!done)
1222         {
1223                 done = 1;
1224                 for( int i = 0; i < src->total - 1; i++ ) {
1225                         BC_ListBoxItem *item1 = src->values[i];
1226                         BC_ListBoxItem *item2 = src->values[i + 1];
1227                         item1->set_autoplace_icon(1);
1228                         item2->set_autoplace_icon(1);
1229                         item1->set_autoplace_text(1);
1230                         item2->set_autoplace_text(1);
1231                         if( strcmp(item1->get_text(), item2->get_text()) > 0 ) {
1232                                 src->values[i + 1] = item1;
1233                                 src->values[i] = item2;
1234                                 done = 0;
1235                         }
1236                 }
1237         }
1238 }
1239
1240
1241 void AWindowGUI::filter_displayed_assets()
1242 {
1243         //allow_iconlisting = 1;
1244         asset_titles[0] = C_("Title");
1245         asset_titles[1] = _("Comments");
1246
1247         switch( mwindow->edl->session->awindow_folder ) {
1248         case AW_AEFFECT_FOLDER:
1249                 copy_picons(displayed_assets, &aeffects, AW_NO_FOLDER);
1250                 break;
1251         case AW_VEFFECT_FOLDER:
1252                 copy_picons(displayed_assets, &veffects, AW_NO_FOLDER);
1253                 break;
1254         case AW_ATRANSITION_FOLDER:
1255                 copy_picons(displayed_assets, &atransitions, AW_NO_FOLDER);
1256                 break;
1257         case AW_VTRANSITION_FOLDER:
1258                 copy_picons(displayed_assets, &vtransitions, AW_NO_FOLDER);
1259                 break;
1260         case AW_LABEL_FOLDER:
1261                 copy_picons(displayed_assets, &labellist, AW_NO_FOLDER);
1262                 asset_titles[0] = _("Time Stamps");
1263                 asset_titles[1] = C_("Title");
1264                 //allow_iconlisting = 0;
1265                 break;
1266         default:
1267                 copy_picons(displayed_assets, &assets, mwindow->edl->session->awindow_folder);
1268                 break;
1269         }
1270
1271         // Ensure the current folder icon is highlighted
1272         int selected_folder = mwindow->edl->session->awindow_folder;
1273         for( int i = 0; i < folders.total; i++ ) {
1274                 AssetPicon *folder_item = (AssetPicon *)folders.values[i];
1275                 int selected = folder_item->foldernum == selected_folder ? 1 : 0;
1276                 folder_item->set_selected(selected);
1277         }
1278 }
1279
1280
1281 void AWindowGUI::update_assets()
1282 {
1283         stop_vicon_drawing();
1284         update_folder_list();
1285         update_asset_list();
1286         labellist.remove_all_objects();
1287         create_label_folder();
1288
1289         if( displayed_folder != mwindow->edl->session->awindow_folder )
1290                 search_text->clear();
1291         filter_displayed_assets();
1292
1293         if( mwindow->edl->session->folderlist_format != folder_list->get_format() ) {
1294                 folder_list->update_format(mwindow->edl->session->folderlist_format, 0);
1295         }
1296         int folder_xposition = folder_list->get_xposition();
1297         int folder_yposition = folder_list->get_yposition();
1298         folder_list->update(&folders, 0, 0, 1, folder_xposition, folder_yposition, -1);
1299
1300         if( mwindow->edl->session->assetlist_format != asset_list->get_format() ) {
1301                 asset_list->update_format(mwindow->edl->session->assetlist_format, 0);
1302         }
1303         int asset_xposition = asset_list->get_xposition();
1304         int asset_yposition = asset_list->get_yposition();
1305         if( displayed_folder != mwindow->edl->session->awindow_folder ) {
1306                 displayed_folder = mwindow->edl->session->awindow_folder;
1307                 asset_xposition = asset_yposition = 0;
1308         }
1309         asset_list->update(displayed_assets, asset_titles,
1310                 mwindow->edl->session->asset_columns, ASSET_COLUMNS,
1311                 asset_xposition, asset_yposition, -1, 0);
1312         asset_list->center_selection();
1313
1314         flush();
1315         start_vicon_drawing();
1316         return;
1317 }
1318
1319 void AWindowGUI::update_effects()
1320 {
1321         aeffects.remove_all_objects();
1322         create_persistent_folder(&aeffects, 1, 0, 1, 0);
1323         veffects.remove_all_objects();
1324         create_persistent_folder(&veffects, 0, 1, 1, 0);
1325         atransitions.remove_all_objects();
1326         create_persistent_folder(&atransitions, 1, 0, 0, 1);
1327         vtransitions.remove_all_objects();
1328         create_persistent_folder(&vtransitions, 0, 1, 0, 1);
1329 }
1330
1331 int AWindowGUI::folder_number(const char *name)
1332 {
1333         for( int i = 0; i < AWINDOW_FOLDERS; i++ ) {
1334                 if( !strcasecmp(name, folder_names[i]) ) return i;
1335         }
1336         return AW_NO_FOLDER;
1337 }
1338
1339 int AWindowGUI::drag_motion()
1340 {
1341         if( get_hidden() ) return 0;
1342
1343         int result = 0;
1344         return result;
1345 }
1346
1347 int AWindowGUI::drag_stop()
1348 {
1349         if( get_hidden() ) return 0;
1350
1351         return 0;
1352 }
1353
1354 Indexable* AWindowGUI::selected_asset()
1355 {
1356         AssetPicon *picon = (AssetPicon*)asset_list->get_selection(0, 0);
1357         return picon ? picon->indexable : 0;
1358 }
1359
1360 PluginServer* AWindowGUI::selected_plugin()
1361 {
1362         AssetPicon *picon = (AssetPicon*)asset_list->get_selection(0, 0);
1363         return picon ? picon->plugin : 0;
1364 }
1365
1366 AssetPicon* AWindowGUI::selected_folder()
1367 {
1368         AssetPicon *picon = (AssetPicon*)folder_list->get_selection(0, 0);
1369         return picon;
1370 }
1371
1372
1373
1374
1375
1376
1377
1378
1379 AWindowDivider::AWindowDivider(MWindow *mwindow, AWindowGUI *gui, int x, int y, int w, int h)
1380  : BC_SubWindow(x, y, w, h)
1381 {
1382         this->mwindow = mwindow;
1383         this->gui = gui;
1384 }
1385 AWindowDivider::~AWindowDivider()
1386 {
1387 }
1388
1389 int AWindowDivider::button_press_event()
1390 {
1391         if( is_event_win() && cursor_inside() ) {
1392                 mwindow->session->current_operation = DRAG_PARTITION;
1393                 return 1;
1394         }
1395         return 0;
1396 }
1397
1398 int AWindowDivider::cursor_motion_event()
1399 {
1400         if( mwindow->session->current_operation == DRAG_PARTITION ) {
1401                 int wmin = 25;
1402                 int wmax = mwindow->session->awindow_w - mwindow->theme->adivider_w - wmin;
1403                 int fw = gui->get_relative_cursor_x();
1404                 if( fw > wmax ) fw = wmax;
1405                 if( fw < wmin ) fw = wmin;
1406                 mwindow->session->afolders_w = fw;
1407                 mwindow->theme->get_awindow_sizes(gui);
1408                 gui->reposition_objects();
1409                 gui->flush();
1410         }
1411         return 0;
1412 }
1413
1414 int AWindowDivider::button_release_event()
1415 {
1416         if( mwindow->session->current_operation == DRAG_PARTITION ) {
1417                 mwindow->session->current_operation = NO_OPERATION;
1418                 return 1;
1419         }
1420         return 0;
1421 }
1422
1423
1424
1425
1426
1427
1428 AWindowFolders::AWindowFolders(MWindow *mwindow, AWindowGUI *gui, int x, int y, int w, int h)
1429  : BC_ListBox(x, y, w, h,
1430                 mwindow->edl->session->folderlist_format == ASSETS_ICONS ?
1431                         LISTBOX_ICONS : LISTBOX_TEXT,
1432                 &gui->folders,    // Each column has an ArrayList of BC_ListBoxItems.
1433                 0,                // Titles for columns.  Set to 0 for no titles
1434                 0,                // width of each column
1435                 1,                // Total columns.
1436                 0,                // Pixel of top of window.
1437                 0,                // If this listbox is a popup window
1438                 LISTBOX_SINGLE,   // Select one item or multiple items
1439                 ICON_TOP,         // Position of icon relative to text of each item
1440                 1)                // Allow drags
1441 {
1442         this->mwindow = mwindow;
1443         this->gui = gui;
1444         set_drag_scroll(0);
1445 }
1446
1447 AWindowFolders::~AWindowFolders()
1448 {
1449 }
1450
1451 int AWindowFolders::selection_changed()
1452 {
1453         AssetPicon *picon = (AssetPicon*)get_selection(0, 0);
1454         if( picon ) {
1455                 gui->stop_vicon_drawing();
1456
1457                 if( get_button_down() && get_buttonpress() == 3 ) {
1458                         gui->folderlist_menu->update_titles();
1459                         gui->folderlist_menu->activate_menu();
1460                 }
1461
1462                 mwindow->edl->session->awindow_folder = picon->foldernum;
1463                 gui->asset_list->draw_background();
1464                 gui->async_update_assets();
1465
1466                 gui->start_vicon_drawing();
1467         }
1468         return 1;
1469 }
1470
1471 int AWindowFolders::button_press_event()
1472 {
1473         int result = 0;
1474
1475         result = BC_ListBox::button_press_event();
1476
1477         if( !result ) {
1478                 if( get_buttonpress() == 3 && is_event_win() && cursor_inside() ) {
1479                         gui->folderlist_menu->update_titles();
1480                         gui->folderlist_menu->activate_menu();
1481                         result = 1;
1482                 }
1483         }
1484
1485
1486         return result;
1487 }
1488
1489
1490
1491
1492
1493
1494
1495 AWindowAssets::AWindowAssets(MWindow *mwindow, AWindowGUI *gui, int x, int y, int w, int h)
1496  : BC_ListBox(x, y, w, h,
1497                 (mwindow->edl->session->assetlist_format == ASSETS_ICONS && gui->allow_iconlisting ) ?
1498                         LISTBOX_ICONS : LISTBOX_TEXT,
1499                 &gui->assets,     // Each column has an ArrayList of BC_ListBoxItems.
1500                 gui->asset_titles,// Titles for columns.  Set to 0 for no titles
1501                 mwindow->edl->session->asset_columns, // width of each column
1502                 1,                // Total columns.
1503                 0,                // Pixel of top of window.
1504                 0,                // If this listbox is a popup window
1505                 LISTBOX_MULTIPLE, // Select one item or multiple items
1506                 ICON_TOP,         // Position of icon relative to text of each item
1507                 -1)               // Allow drags, require shift for scrolling
1508 {
1509         this->mwindow = mwindow;
1510         this->gui = gui;
1511         set_drag_scroll(0);
1512         set_scroll_stretch(1, 1);
1513 }
1514
1515 AWindowAssets::~AWindowAssets()
1516 {
1517 }
1518
1519 int AWindowAssets::button_press_event()
1520 {
1521         int result = 0;
1522
1523         result = BC_ListBox::button_press_event();
1524
1525         if( !result && get_buttonpress() == 3 && is_event_win() && cursor_inside() ) {
1526                 BC_ListBox::deactivate_selection();
1527                 int folder = mwindow->edl->session->awindow_folder;
1528                 switch( folder ) {
1529                 case AW_AEFFECT_FOLDER:
1530                 case AW_VEFFECT_FOLDER:
1531                 case AW_ATRANSITION_FOLDER:
1532                 case AW_VTRANSITION_FOLDER:
1533                         gui->effectlist_menu->update();
1534                         gui->effectlist_menu->activate_menu();
1535                         break;
1536                 case AW_LABEL_FOLDER:
1537                         gui->labellist_menu->update();
1538                         gui->labellist_menu->activate_menu();
1539                         break;
1540                 case AW_CLIP_FOLDER:
1541                         gui->cliplist_menu->update();
1542                         gui->cliplist_menu->activate_menu();
1543                         break;
1544                 case AW_MEDIA_FOLDER:
1545                 case AW_PROXY_FOLDER:
1546                         gui->assetlist_menu->update_titles();
1547                         gui->assetlist_menu->activate_menu();
1548                         break;
1549                 }
1550                 result = 1;
1551         }
1552
1553         return result;
1554 }
1555
1556
1557 int AWindowAssets::handle_event()
1558 {
1559         AssetPicon *asset_picon = (AssetPicon *)get_selection(0, 0);
1560         if( !asset_picon ) return 0;
1561         switch( mwindow->edl->session->awindow_folder ) {
1562         case AW_AEFFECT_FOLDER:
1563         case AW_VEFFECT_FOLDER:
1564         case AW_ATRANSITION_FOLDER:
1565         case AW_VTRANSITION_FOLDER: return 1;
1566         }
1567         VWindow *vwindow = mwindow->vwindows.size() > DEFAULT_VWINDOW ?
1568                 mwindow->vwindows.get(DEFAULT_VWINDOW) : 0;
1569         if( !vwindow || !vwindow->is_running() ) return 1;
1570
1571         vwindow->gui->lock_window("AWindowAssets::handle_event");
1572         if( asset_picon->indexable )
1573                 vwindow->change_source(asset_picon->indexable);
1574         else if( asset_picon->edl )
1575                 vwindow->change_source(asset_picon->edl);
1576         vwindow->gui->unlock_window();
1577         return 1;
1578 }
1579
1580 int AWindowAssets::selection_changed()
1581 {
1582 // Show popup window
1583         AssetPicon *item;
1584         if( get_button_down() && get_buttonpress() == 3 &&
1585             (item = (AssetPicon*)get_selection(0, 0)) ) {
1586                 int folder = mwindow->edl->session->awindow_folder;
1587                 switch( folder ) {
1588                 case AW_AEFFECT_FOLDER:
1589                 case AW_VEFFECT_FOLDER:
1590                 case AW_ATRANSITION_FOLDER:
1591                 case AW_VTRANSITION_FOLDER:
1592                         gui->effectlist_menu->update();
1593                         gui->effectlist_menu->activate_menu();
1594                         break;
1595                 case AW_LABEL_FOLDER:
1596                         if( !item->label ) break;
1597                         gui->label_menu->activate_menu();
1598                         break;
1599                 case AW_CLIP_FOLDER:
1600                         if( !item->indexable && !item->edl ) break;
1601                         gui->clip_menu->update();
1602                         gui->clip_menu->activate_menu();
1603                         break;
1604                 default:
1605                         if( !item->indexable && !item->edl ) break;
1606                         gui->asset_menu->update();
1607                         gui->asset_menu->activate_menu();
1608                         break;
1609                 }
1610
1611                 BC_ListBox::deactivate_selection();
1612                 return 1;
1613         }
1614         else if( get_button_down() && get_buttonpress() == 1 &&
1615                  (item = (AssetPicon*)get_selection(0, 0)) ) {
1616                 VIcon *vicon = 0;
1617                 if( !gui->vicon_thread->viewing ) {
1618                         vicon = item->vicon;
1619                 }
1620                 gui->vicon_thread->set_view_popup(vicon);
1621
1622         }
1623         return 0;
1624 }
1625
1626 void AWindowAssets::draw_background()
1627 {
1628         clear_box(0,0,get_w(),get_h(),get_bg_surface());
1629         set_color(BC_WindowBase::get_resources()->audiovideo_color);
1630         set_font(LARGEFONT);
1631         int aw_folder = mwindow->edl->session->awindow_folder;
1632         if( aw_folder < 0 ) return;
1633         const char *aw_name = _(AWindowGUI::folder_names[aw_folder]);
1634         draw_text(get_w() - get_text_width(LARGEFONT, aw_name) - 4, 30,
1635                 aw_name, -1, get_bg_surface());
1636 }
1637
1638 int AWindowAssets::drag_start_event()
1639 {
1640         int collect_pluginservers = 0;
1641         int collect_assets = 0;
1642
1643         if( BC_ListBox::drag_start_event() ) {
1644                 switch( mwindow->edl->session->awindow_folder ) {
1645                 case AW_AEFFECT_FOLDER:
1646                         mwindow->session->current_operation = DRAG_AEFFECT;
1647                         collect_pluginservers = 1;
1648                         break;
1649                 case AW_VEFFECT_FOLDER:
1650                         mwindow->session->current_operation = DRAG_VEFFECT;
1651                         collect_pluginservers = 1;
1652                         break;
1653                 case AW_ATRANSITION_FOLDER:
1654                         mwindow->session->current_operation = DRAG_ATRANSITION;
1655                         collect_pluginservers = 1;
1656                         break;
1657                 case AW_VTRANSITION_FOLDER:
1658                         mwindow->session->current_operation = DRAG_VTRANSITION;
1659                         collect_pluginservers = 1;
1660                         break;
1661                 case AW_LABEL_FOLDER:
1662                         // do nothing!
1663                         break;
1664                 default:
1665                         mwindow->session->current_operation = DRAG_ASSET;
1666                         collect_assets = 1;
1667                         break;
1668                 }
1669
1670                 if( collect_pluginservers ) {
1671                         int i = 0;
1672                         mwindow->session->drag_pluginservers->remove_all();
1673                         while(1)
1674                         {
1675                                 AssetPicon *result = (AssetPicon*)get_selection(0, i++);
1676                                 if( !result ) break;
1677
1678                                 mwindow->session->drag_pluginservers->append(result->plugin);
1679                         }
1680                 }
1681
1682                 if( collect_assets ) {
1683                         gui->collect_assets();
1684                 }
1685
1686                 return 1;
1687         }
1688         return 0;
1689 }
1690
1691 int AWindowAssets::drag_motion_event()
1692 {
1693         BC_ListBox::drag_motion_event();
1694         unlock_window();
1695
1696         mwindow->gui->lock_window("AWindowAssets::drag_motion_event");
1697         mwindow->gui->drag_motion();
1698         mwindow->gui->unlock_window();
1699
1700         for( int i = 0; i < mwindow->vwindows.size(); i++ ) {
1701                 VWindow *vwindow = mwindow->vwindows.get(i);
1702                 if( !vwindow->is_running() ) continue;
1703                 vwindow->gui->lock_window("AWindowAssets::drag_motion_event");
1704                 vwindow->gui->drag_motion();
1705                 vwindow->gui->unlock_window();
1706         }
1707
1708         mwindow->cwindow->gui->lock_window("AWindowAssets::drag_motion_event");
1709         mwindow->cwindow->gui->drag_motion();
1710         mwindow->cwindow->gui->unlock_window();
1711
1712         lock_window("AWindowAssets::drag_motion_event");
1713         return 0;
1714 }
1715
1716 int AWindowAssets::drag_stop_event()
1717 {
1718         int result = 0;
1719
1720         result = gui->drag_stop();
1721
1722         unlock_window();
1723
1724         if( !result ) {
1725                 mwindow->gui->lock_window("AWindowAssets::drag_stop_event");
1726                 result = mwindow->gui->drag_stop();
1727                 mwindow->gui->unlock_window();
1728         }
1729
1730         if( !result ) {
1731                 for( int i = 0; !result && i < mwindow->vwindows.size(); i++ ) {
1732                         VWindow *vwindow = mwindow->vwindows.get(i);
1733                         if( !vwindow ) continue;
1734                         if( !vwindow->is_running() ) continue;
1735                         if( vwindow->gui->is_hidden() ) continue;
1736                         vwindow->gui->lock_window("AWindowAssets::drag_stop_event");
1737                         if( vwindow->gui->cursor_above() &&
1738                             vwindow->gui->get_cursor_over_window() ) {
1739                                 result = vwindow->gui->drag_stop();
1740                         }
1741                         vwindow->gui->unlock_window();
1742                 }
1743         }
1744
1745         if( !result ) {
1746                 mwindow->cwindow->gui->lock_window("AWindowAssets::drag_stop_event");
1747                 result = mwindow->cwindow->gui->drag_stop();
1748                 mwindow->cwindow->gui->unlock_window();
1749         }
1750
1751         lock_window("AWindowAssets::drag_stop_event");
1752
1753         if( result )
1754                 get_drag_popup()->set_animation(0);
1755
1756         BC_ListBox::drag_stop_event();
1757 // since NO_OPERATION is also defined in listbox, we have to reach for global scope...
1758         mwindow->session->current_operation = ::NO_OPERATION;
1759         return 1;
1760 }
1761
1762 int AWindowAssets::column_resize_event()
1763 {
1764         mwindow->edl->session->asset_columns[0] = get_column_width(0);
1765         mwindow->edl->session->asset_columns[1] = get_column_width(1);
1766         return 1;
1767 }
1768
1769 int AWindowAssets::focus_in_event()
1770 {
1771         gui->start_vicon_drawing();
1772         return 0;
1773 }
1774
1775 int AWindowAssets::focus_out_event()
1776 {
1777         gui->stop_vicon_drawing();
1778         return BC_ListBox::focus_out_event();
1779 }
1780
1781 AWindowSearchTextBox::AWindowSearchTextBox(AWindowSearchText *search_text, int x, int y, int w)
1782  : BC_TextBox(x, y, w, 1, "")
1783 {
1784         this->search_text = search_text;
1785 }
1786
1787 int AWindowSearchTextBox::handle_event()
1788 {
1789         return search_text->handle_event();
1790 }
1791
1792 AWindowSearchText::AWindowSearchText(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1793 {
1794         this->mwindow = mwindow;
1795         this->gui = gui;
1796         this->x = x;
1797         this->y = y;
1798 }
1799
1800 void AWindowSearchText::create_objects()
1801 {
1802         int x1 = x, y1 = y, margin = 10;
1803         gui->add_subwindow(text_title = new BC_Title(x1, y1, _("Search:")));
1804         x1 += text_title->get_w() + margin;
1805         int w1 = gui->get_w() - x1 - 2*margin;
1806         gui->add_subwindow(text_box = new AWindowSearchTextBox(this, x1, y1, w1));
1807 }
1808
1809 int AWindowSearchText::handle_event()
1810 {
1811         gui->async_update_assets();
1812         return 1;
1813 }
1814
1815 int AWindowSearchText::get_w()
1816 {
1817         return text_box->get_w() + text_title->get_w() + 10;
1818 }
1819
1820 int AWindowSearchText::get_h()
1821 {
1822         return bmax(text_box->get_h(),text_title->get_h());
1823 }
1824
1825 void AWindowSearchText::reposition_window(int x, int y, int w)
1826 {
1827         int x1 = x, y1 = y, margin = 10;
1828         text_title->reposition_window(x1, y1);
1829         x1 += text_title->get_w() + margin;
1830         int w1 = gui->get_w() - x1 - 2*margin;
1831         text_box->reposition_window(x1, y1, w1);
1832 }
1833
1834 const char *AWindowSearchText::get_text()
1835 {
1836         return text_box->get_text();
1837 }
1838
1839 void AWindowSearchText::clear()
1840 {
1841         text_box->update("");
1842 }
1843
1844 AWindowNewFolder::AWindowNewFolder(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1845  : BC_Button(x, y, mwindow->theme->newbin_data)
1846 {
1847         this->mwindow = mwindow;
1848         this->gui = gui;
1849         set_tooltip(_("New bin"));
1850 }
1851
1852 int AWindowNewFolder::handle_event()
1853 {
1854         gui->newfolder_thread->start_new_folder();
1855         return 1;
1856 }
1857
1858 AWindowDeleteFolder::AWindowDeleteFolder(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1859  : BC_Button(x, y, mwindow->theme->deletebin_data)
1860 {
1861         this->mwindow = mwindow;
1862         this->gui = gui;
1863         set_tooltip(_("Delete bin"));
1864 }
1865
1866 int AWindowDeleteFolder::handle_event()
1867 {
1868         if( gui->folder_list->get_selection(0, 0) ) {
1869                 BC_ListBoxItem *folder = gui->folder_list->get_selection(0, 0);
1870                 mwindow->delete_folder(folder->get_text());
1871         }
1872         return 1;
1873 }
1874
1875 AWindowRenameFolder::AWindowRenameFolder(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1876  : BC_Button(x, y, mwindow->theme->renamebin_data)
1877 {
1878         this->mwindow = mwindow;
1879         this->gui = gui;
1880         set_tooltip(_("Rename bin"));
1881 }
1882
1883 int AWindowRenameFolder::handle_event()
1884 {
1885         return 1;
1886 }
1887
1888 AWindowDeleteDisk::AWindowDeleteDisk(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1889  : BC_Button(x, y, mwindow->theme->deletedisk_data)
1890 {
1891         this->mwindow = mwindow;
1892         this->gui = gui;
1893         set_tooltip(_("Delete asset from disk"));
1894 }
1895
1896 int AWindowDeleteDisk::handle_event()
1897 {
1898         return 1;
1899 }
1900
1901 AWindowDeleteProject::AWindowDeleteProject(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1902  : BC_Button(x, y, mwindow->theme->deleteproject_data)
1903 {
1904         this->mwindow = mwindow;
1905         this->gui = gui;
1906         set_tooltip(_("Delete asset from project"));
1907 }
1908
1909 int AWindowDeleteProject::handle_event()
1910 {
1911         return 1;
1912 }
1913
1914 // AWindowInfo::AWindowInfo(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1915 //  : BC_Button(x, y, mwindow->theme->infoasset_data)
1916 // {
1917 //      this->mwindow = mwindow;
1918 //      this->gui = gui;
1919 //      set_tooltip(_("Edit information on asset"));
1920 // }
1921 // 
1922 // int AWindowInfo::handle_event()
1923 // {
1924 //      int cur_x, cur_y;
1925 //      gui->get_abs_cursor(cur_x, cur_y, 0);
1926 //      gui->awindow->asset_edit->edit_asset(gui->selected_asset(), cur_x, cur_y);
1927 //      return 1;
1928 // }
1929
1930 AWindowRedrawIndex::AWindowRedrawIndex(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1931  : BC_Button(x, y, mwindow->theme->redrawindex_data)
1932 {
1933         this->mwindow = mwindow;
1934         this->gui = gui;
1935         set_tooltip(_("Redraw index"));
1936 }
1937
1938 int AWindowRedrawIndex::handle_event()
1939 {
1940         return 1;
1941 }
1942
1943 AWindowPaste::AWindowPaste(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1944  : BC_Button(x, y, mwindow->theme->pasteasset_data)
1945 {
1946         this->mwindow = mwindow;
1947         this->gui = gui;
1948         set_tooltip(_("Paste asset on recordable tracks"));
1949 }
1950
1951 int AWindowPaste::handle_event()
1952 {
1953         return 1;
1954 }
1955
1956 AWindowAppend::AWindowAppend(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1957  : BC_Button(x, y, mwindow->theme->appendasset_data)
1958 {
1959         this->mwindow = mwindow;
1960         this->gui = gui;
1961         set_tooltip(_("Append asset in new tracks"));
1962 }
1963
1964 int AWindowAppend::handle_event()
1965 {
1966         return 1;
1967 }
1968
1969 AWindowView::AWindowView(MWindow *mwindow, AWindowGUI *gui, int x, int y)
1970  : BC_Button(x, y, mwindow->theme->viewasset_data)
1971 {
1972         this->mwindow = mwindow;
1973         this->gui = gui;
1974         set_tooltip(_("View asset"));
1975 }
1976
1977 int AWindowView::handle_event()
1978 {
1979         return 1;
1980 }
1981
1982 AddTools::AddTools(MWindow *mwindow, AWindowGUI *gui, int x, int y, const char *title)
1983  : BC_PopupMenu(x, y, BC_Title::calculate_w(gui, title, MEDIUMFONT)+8, title, -1, 0, 4)
1984 {
1985         this->mwindow = mwindow;
1986         this->gui = gui;
1987 }
1988
1989 void AddTools::create_objects()
1990 {
1991         uint64_t vis = 0;
1992         add_item(new AddPluginItem(this, "ladspa", PLUGIN_LADSPA_ID));
1993         vis |= 1 << PLUGIN_LADSPA_ID;
1994         add_item(new AddPluginItem(this, "ffmpeg", PLUGIN_FFMPEG_ID));
1995         vis |= 1 << PLUGIN_FFMPEG_ID;
1996         for( int i=0; i<MWindow::plugindb->size(); ++i ) {
1997                 PluginServer *plugin = MWindow::plugindb->get(i);
1998                 if( !plugin->audio && !plugin->video ) continue;
1999                 int idx = plugin->dir_idx;
2000                 uint32_t msk = 1 << idx;
2001                 if( (msk & vis) != 0 ) continue;
2002                 vis |= msk;
2003                 char parent[BCTEXTLEN];
2004                 strcpy(parent, plugin->path);
2005                 char *bp = strrchr(parent, '/');
2006                 if( bp ) { *bp = 0;  bp = strrchr(parent, '/'); }
2007                 if( !bp ) bp = parent; else ++bp;
2008                 add_item(new AddPluginItem(this, bp, idx));
2009         }
2010 }
2011
2012 #if 0
2013 // plugin_dirs list from toplevel makefile include plugin_defs
2014 N_("ladspa")
2015 N_("ffmpeg")
2016 N_("audio_tools")
2017 N_("audio_transitions")
2018 N_("blending")
2019 N_("colors")
2020 N_("exotic")
2021 N_("transforms")
2022 N_("tv_effects")
2023 N_("video_tools")
2024 N_("video_transitions")
2025 #endif
2026
2027 AddPluginItem::AddPluginItem(AddTools *menu, char const *text, int idx)
2028  : BC_MenuItem(_(text))
2029 {
2030         this->menu = menu;
2031         this->idx = idx;
2032         uint64_t msk = (uint64_t)1 << idx, vis = menu->gui->plugin_visibility;
2033         int chk = (msk & vis) ? 1 : 0;
2034         set_checked(chk);
2035 }
2036
2037 int AddPluginItem::handle_event()
2038 {
2039         int chk = get_checked() ^ 1;
2040         set_checked(chk);
2041         uint64_t msk = (uint64_t)1 << idx, vis = menu->gui->plugin_visibility;
2042         menu->gui->plugin_visibility = chk ? vis | msk : vis & ~msk;
2043         menu->gui->update_effects();
2044         menu->gui->save_defaults(menu->mwindow->defaults);
2045         menu->gui->async_update_assets();
2046         return 1;
2047 }
2048
2049 AVIconDrawing::AVIconDrawing(AWindowGUI *agui, int x, int y, VFrame **images)
2050  : BC_Toggle(x, y, images, agui->vicon_drawing)
2051 {
2052         this->agui = agui;
2053         set_tooltip(_("draw vicons"));
2054 }
2055
2056 void AVIconDrawing::calculate_geometry(AWindowGUI *agui, VFrame **images, int *ww, int *hh)
2057 {
2058         int text_line = -1, toggle_x = -1, toggle_y = -1;
2059         int text_x = -1, text_y = -1, text_w = -1, text_h = -1;
2060         BC_Toggle::calculate_extents(agui, images, 1,
2061                 &text_line, ww, hh, &toggle_x, &toggle_y,
2062                 &text_x, &text_y, &text_w, &text_h, "", MEDIUMFONT);
2063 }
2064
2065 AVIconDrawing::~AVIconDrawing()
2066 {
2067 }
2068
2069 int AVIconDrawing::handle_event()
2070 {
2071         agui->vicon_drawing = get_value();
2072         if( agui->vicon_drawing )
2073                 agui->start_vicon_drawing();
2074         else
2075                 agui->stop_vicon_drawing();
2076         return 1;
2077 }
2078
2079
2080 AWindowListFormat::AWindowListFormat(MWindow *mwindow, AWindowGUI *gui)
2081  : BC_MenuItem("")
2082 {
2083         this->mwindow = mwindow;
2084         this->gui = gui;
2085 }
2086
2087 int AWindowListFormat::handle_event()
2088 {
2089         gui->stop_vicon_drawing();
2090
2091         EDLSession *session = mwindow->edl->session;
2092         switch( session->assetlist_format ) {
2093         case ASSETS_TEXT:
2094                 session->assetlist_format = ASSETS_ICONS;
2095                 break;
2096         case ASSETS_ICONS:
2097                 session->assetlist_format = ASSETS_TEXT;
2098                 break;
2099         }
2100
2101         gui->asset_list->update_format(session->assetlist_format, 1);
2102         if( !mwindow->awindow->gui->allow_iconlisting ) {
2103                 mwindow->edl->session->assetlist_format = ASSETS_TEXT;
2104         }
2105
2106         gui->start_vicon_drawing();
2107         return 1;
2108 }
2109
2110 void AWindowListFormat::update()
2111 {
2112         set_text(mwindow->edl->session->assetlist_format == ASSETS_TEXT ?
2113                 (char*)_("Display icons") : (char*)_("Display text"));
2114 }
2115
2116 AWindowListSort::AWindowListSort(MWindow *mwindow, AWindowGUI *gui)
2117  : BC_MenuItem(_("Sort items"))
2118 {
2119         this->mwindow = mwindow;
2120         this->gui = gui;
2121 }
2122
2123 int AWindowListSort::handle_event()
2124 {
2125         gui->sort_assets();
2126         return 1;
2127 }
2128