cinelerra-5.1/cinelerra/zwindow.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 "bcdialog.h"
  23 #include "edl.h"
  24 #include "filexml.h"
  25 #include "language.h"
  26 #include "mainsession.h"
  27 #include "mwindow.h"
  28 #include "mwindowgui.h"
  29 #include "patchbay.h"
  30 #include "patchgui.h"
  31 #include "playbackengine.h"
  32 #include "renderengine.h"
  33 #include "timelinepane.h"
  34 #include "track.h"
  35 #include "tracks.h"
  36 #include "transportque.h"
  37 #include "zwindow.h"
  38 #include "zwindowgui.h"
  39
  40 Mixers::Mixers()
  41 {
  42 }
  43
  44 Mixers::~Mixers()
  45 {
  46         remove_all_objects();
  47 }
  48
  49 Mixer *Mixers::new_mixer(int show)
  50 {
  51         int idx = 0;
  52         for( int i=0; i<size(); ++i ) {
  53                 Mixer *mixer = get(i);
  54                 if( idx < mixer->idx ) idx = mixer->idx;
  55         }
  56         return append(new Mixer(idx+1, show));
  57 }
  58
  59 Mixer *Mixers::get_mixer(int idx)
  60 {
  61         for( int i=0; i<size(); ++i ) {
  62                 Mixer *mixer = get(i);
  63                 if( mixer->idx == idx ) return mixer;
  64         }
  65         return 0;
  66 }
  67
  68 void Mixers::del_mixer(Mixer *mixer)
  69 {
  70         remove_object(mixer);
  71 }
  72
  73 void Mixer::set_title(const char *tp)
  74 {
  75         if( tp == title ) return;
  76         strncpy(title, !tp ? "" : tp, sizeof(title));
  77         title[sizeof(title)-1] = 0;
  78 }
  79
  80 void Mixers::save(FileXML *file)
  81 {
  82         file->tag.set_title("MIXERS");
  83         file->append_tag();
  84         file->append_newline();
  85         for( int i=0; i<size(); ++i ) {
  86                 Mixer *mixer = get(i);
  87                 mixer->save(file);
  88         }
  89         file->tag.set_title("/MIXERS");
  90         file->append_tag();
  91         file->append_newline();
  92 }
  93
  94 int Mixers::load(FileXML *file)
  95 {
  96         int result = 0;
  97         while( !(result = file->read_tag()) ) {
  98                 if( file->tag.title_is("/MIXERS") ) break;
  99                 if( file->tag.title_is("MIXER") ) {
 100                         Mixer *mixer = new_mixer();
 101                         file->tag.get_property("TITLE", mixer->title);
 102                         mixer->show = file->tag.get_property("SHOW", 1);
 103                         mixer->x = file->tag.get_property("X", mixer->x);
 104                         mixer->y = file->tag.get_property("Y", mixer->y);
 105                         mixer->w = file->tag.get_property("W", mixer->w);
 106                         mixer->h = file->tag.get_property("H", mixer->h);
 107                         mixer->load(file);
 108                 }
 109         }
 110         return 0;
 111 }
 112
 113 void Mixers::copy_from(Mixers &that)
 114 {
 115         remove_all_objects();
 116         for( int i=0; i<that.size(); ++i ) {
 117                 Mixer *mixer = new_mixer();
 118                 mixer->copy_from(*that[i]);
 119         }
 120 }
 121
 122 void Mixer::save(FileXML *file)
 123 {
 124         file->tag.set_title("MIXER");
 125         file->tag.set_property("SHOW",show);
 126         file->tag.set_property("TITLE",title);
 127         file->tag.set_property("X",x);
 128         file->tag.set_property("Y",y);
 129         file->tag.set_property("W",w);
 130         file->tag.set_property("H",h);
 131         file->append_tag();
 132         file->append_newline();
 133         for( int i=0; i<mixer_ids.size(); ++i ) {
 134                 file->tag.set_title("MIX");
 135                 file->tag.set_property("ID", mixer_ids[i]);
 136                 file->append_tag();
 137                 file->tag.set_title("/MIX");
 138                 file->append_tag();
 139                 file->append_newline();
 140         }
 141         file->tag.set_title("/MIXER");
 142         file->append_tag();
 143         file->append_newline();
 144 }
 145
 146 Mixer::Mixer(int idx, int show)
 147 {
 148         this->idx = idx;
 149         this->show = show;
 150         title[0] = 0;
 151         x = y = 100 + idx*64;
 152         w = 400;  h = 300;
 153 }
 154 void Mixer::reposition(int x, int y, int w, int h)
 155 {
 156         this->x = x;  this->y = y;
 157         this->w = w;  this->h = h;
 158 }
 159
 160 int Mixer::load(FileXML *file)
 161 {
 162         int result = 0;
 163         while( !(result = file->read_tag()) ) {
 164                 if( file->tag.title_is("/MIXER") ) break;
 165                 if( file->tag.title_is("MIX") ) {
 166                         mixer_ids.append(file->tag.get_property("ID", 0));
 167                 }
 168         }
 169         return 0;
 170 }
 171
 172 void Mixer::copy_from(Mixer &that)
 173 {
 174         mixer_ids.remove_all();
 175         strncpy(title, that.title, sizeof(title));
 176         title[sizeof(title)-1] = 0;
 177         x = that.x;  y = that.y;
 178         w = that.w;  h = that.h;
 179         for( int i=0; i<that.mixer_ids.size(); ++i )
 180                 mixer_ids.append(that.mixer_ids[i]);
 181 }
 182
 183
 184 ZWindow::ZWindow(MWindow *mwindow)
 185  : BC_DialogThread()
 186 {
 187         this->mwindow = mwindow;
 188         idx = -1;
 189         edl = 0;
 190         highlighted = 0;
 191         playable = 1;
 192         title[0] = 0;
 193         zgui = 0;
 194         zoom = 0;
 195 }
 196
 197 ZWindow::~ZWindow()
 198 {
 199         close_window();
 200         if( edl )
 201                 edl->remove_user();
 202 }
 203
 204 BC_Window* ZWindow::new_gui()
 205 {
 206         Mixer *mixer = mwindow->edl->mixers.get_mixer(idx);
 207         mixer->show = 1;
 208         zgui = new ZWindowGUI(mwindow, this, mixer);
 209         zgui->create_objects();
 210         return zgui;
 211 }
 212
 213 void ZWindow::handle_done_event(int result)
 214 {
 215         stop_playback(1);
 216         if( result ) {
 217                 mwindow->close_mixer(this);
 218                 Mixer *mixer = mwindow->edl->mixers.get_mixer(idx);
 219                 if( mixer ) mixer->show = 0;
 220                 Track *track = mixer ? mwindow->edl->tracks->first : 0;
 221                 while( track && track->index_in(mixer) < 0 ) track = track->next;
 222 // if no refs to tracks, delete it
 223                 if( !track ) mwindow->edl->mixers.del_mixer(mixer);
 224         }
 225         idx = -1;
 226 }
 227 void ZWindow::handle_close_event(int result)
 228 {
 229         zgui = 0;
 230 }
 231
 232 void ZWindow::change_source(EDL *edl)
 233 {
 234         if( this->edl == edl ) return;
 235         zgui->playback_engine->refresh_frame(CHANGE_ALL, edl);
 236         if( this->edl )
 237                 this->edl->remove_user();
 238         this->edl = edl;
 239 }
 240
 241 void ZWindow::stop_playback(int wait)
 242 {
 243         zgui->playback_engine->stop_playback(wait);
 244 }
 245
 246 void ZWindow::handle_mixer(int command, int wait_tracking,
 247                 int use_inout, int toggle_audio, int loop_play, float speed)
 248 {
 249         if( !playable ) return;
 250         PlaybackEngine *engine = zgui->playback_engine;
 251         engine->next_command->toggle_audio = toggle_audio;
 252         engine->next_command->loop_play = loop_play;
 253         engine->next_command->speed = speed;
 254         engine->send_command(command, edl, wait_tracking, use_inout);
 255 }
 256
 257 void ZWindow::update_mixer_ids()
 258 {
 259         if( !running() ) return;
 260         Mixer *mixer = mwindow->edl->mixers.get_mixer(idx);
 261         if( !mixer ) return;
 262         mixer->mixer_ids.remove_all();
 263         PatchBay *patchbay = mwindow->gui->pane[0]->patchbay;
 264         for( int i=0; i<patchbay->patches.size(); ++i ) {
 265                 PatchGUI *patchgui = patchbay->patches[i];
 266                 if( !patchgui->mixer ) continue;
 267                 int mixer_id = patchgui->track->get_mixer_id();
 268                 if( mixer->mixer_ids.number_of(mixer_id) >= 0 ) continue;
 269                 mixer->mixer_ids.append(mixer_id);
 270         }
 271 }
 272
 273 void ZWindow::set_title(const char *tp)
 274 {
 275         Track *track = 0;
 276         Mixer *mixer = mwindow->edl->mixers.get_mixer(idx);
 277         if( mixer ) {
 278                 mixer->set_title(tp);
 279                 for( track=mwindow->edl->tracks->first; track; track=track->next ) {
 280                         if( track->data_type != TRACK_VIDEO ) continue;
 281                         int mixer_id = track->get_mixer_id();
 282                         int k = mixer->mixer_ids.size();
 283                         while( --k >= 0 && mixer_id != mixer->mixer_ids[k] );
 284                         if( k >= 0 ) break;
 285                 }
 286         }
 287         char *cp = title, *ep = cp + sizeof(title)-1;
 288         cp += snprintf(title, ep-cp, track ? track->title : _("Mixer %d"), idx);
 289         if( tp ) cp += snprintf(cp, ep-cp, ": %s", tp);
 290         *cp = 0;
 291 }
 292
 293 void ZWindow::reposition(int x, int y, int w, int h)
 294 {
 295         Mixer *mixer = mwindow->edl->mixers.get_mixer(idx);
 296         if( !mixer ) return;
 297         mixer->reposition(x, y, w, h);
 298 }
 299