cinelerra-5.1/cinelerra/resizetrackthread.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 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 "edl.h"
  25 #include "edlsession.h"
  26 #include "language.h"
  27 #include "mainerror.h"
  28 #include "mainundo.h"
  29 #include "mwindow.h"
  30 #include "mwindowgui.h"
  31 #include "new.h"
  32 #include "resizetrackthread.h"
  33 #include "theme.h"
  34 #include "track.h"
  35 #include "tracks.h"
  36
  37
  38
  39
  40
  41
  42 ResizeVTrackThread::ResizeVTrackThread(MWindow *mwindow)
  43  : Thread(1, 0, 0)
  44 {
  45         this->mwindow = mwindow;
  46         window = 0;
  47 }
  48
  49 ResizeVTrackThread::~ResizeVTrackThread()
  50 {
  51         if(window)
  52         {
  53                 window->lock_window();
  54                 window->set_done(1);
  55                 window->unlock_window();
  56         }
  57
  58         Thread::join();
  59 }
  60
  61 void ResizeVTrackThread::start_window(int w, int h, int w1, int h1)
  62 {
  63         if( window && running() ) {
  64                 window->lock_window();
  65                 window->raise_window();
  66                 window->unlock_window();
  67                 return;
  68         }
  69         this->w = w;    this->h = h;
  70         this->w1 = w1;  this->h1 = h1;
  71         w_scale = (float)w / w1;
  72         h_scale = (float)h / h1;
  73         start();
  74 }
  75
  76
  77 void ResizeVTrackThread::run()
  78 {
  79         window = new ResizeVTrackWindow(mwindow, this,
  80                         mwindow->gui->get_abs_cursor_x(1),
  81                         mwindow->gui->get_abs_cursor_y(1));
  82         window->create_objects();
  83         int result = window->run_window();
  84
  85         delete window;  window = 0;
  86         if(!result) {
  87                 update();
  88         }
  89 #ifdef GLx4
  90         if(((w % 4) || (h % 4)) &&
  91                 mwindow->edl->session->playback_config->vconfig->driver == PLAYBACK_X11_GL)
  92         {
  93                 MainError::show_error(
  94                         _("This track's dimensions are not multiples of 4 so\n"
  95                         "it can't be rendered by OpenGL."));
  96         }
  97 #endif
  98 }
  99
 100 #define RSZ_W xS(330)
 101 #define RSZ_H yS(120)
 102
 103 ResizeVTrackWindow::ResizeVTrackWindow(MWindow *mwindow,
 104                 ResizeVTrackThread *thread, int x, int y)
 105  : BC_Window(_(PROGRAM_NAME ": Resize Track"), x-RSZ_W/2, y-RSZ_H/2,
 106                 RSZ_W, RSZ_H, RSZ_W, RSZ_H, 0, 0, 1)
 107 {
 108         this->mwindow = mwindow;
 109         this->thread = thread;
 110 }
 111
 112 ResizeVTrackWindow::~ResizeVTrackWindow()
 113 {
 114 }
 115
 116 void ResizeVTrackWindow::create_objects()
 117 {
 118         int xs5 = xS(5), xs10 = xS(10);
 119         int ys10 = yS(10);
 120         lock_window("ResizeVTrackWindow::create_objects");
 121         int x = xs10, y = ys10;
 122         BC_Title *size_title = new BC_Title(x, y, _("Size:"));
 123         add_subwindow(size_title);
 124         int x1 = x + size_title->get_w();
 125         int y1 = y + size_title->get_h() + ys10;
 126         BC_Title *scale_title = new BC_Title(x, y1, _("Scale:"));
 127         add_subwindow(scale_title);
 128         int x2 = x + scale_title->get_w();
 129         if( x2 > x1 ) x1 = x2;
 130         x1 += ys10;
 131         add_subwindow(w = new ResizeVTrackWidth(this, thread, x1, y));
 132         x2 = x1 + w->get_w() + xs5;
 133         BC_Title *xy = new BC_Title(x2, y, _("x"));
 134         add_subwindow(xy);
 135         int x3 = x2 + xy->get_w() + xs5;
 136         add_subwindow(h = new ResizeVTrackHeight(this, thread, x3, y));
 137         x = x3 + h->get_w() + xs5;
 138         FrameSizePulldown *pulldown;
 139         add_subwindow(pulldown = new FrameSizePulldown(mwindow->theme, w, h, x, y));
 140         x += pulldown->get_w() + xs5;
 141         add_subwindow(new ResizeVTrackSwap(this, thread, x, y));
 142
 143         add_subwindow(w_scale = new ResizeVTrackScaleW(this, thread, x1, y1));
 144         add_subwindow(new BC_Title(x2, y1, _("x")));
 145         add_subwindow(h_scale = new ResizeVTrackScaleH(this, thread, x3, y1));
 146         x = x3 + h_scale->get_w() + xs5;
 147         add_subwindow(reset = new ResizeReset(this, thread, x, y1));
 148
 149         add_subwindow(new BC_OKButton(this));
 150         add_subwindow(new BC_CancelButton(this));
 151
 152         show_window();
 153         flush();
 154         unlock_window();
 155 }
 156
 157 void ResizeVTrackWindow::update(int changed_scale, int changed_size)
 158 {
 159         if( changed_scale ) {
 160                 thread->w = (int)(thread->w1 * thread->w_scale);
 161                 w->update((int64_t)thread->w);
 162                 thread->h = (int)(thread->h1 * thread->h_scale);
 163                 h->update((int64_t)thread->h);
 164         }
 165         if( changed_size ) {
 166                 thread->w_scale = thread->w1 ? (double)thread->w / thread->w1 : 1.;
 167                 w_scale->update((float)thread->w_scale);
 168                 thread->h_scale = thread->h1 ? (double)thread->h / thread->h1 : 1.;
 169                 h_scale->update((float)thread->h_scale);
 170         }
 171 }
 172
 173
 174
 175
 176 ResizeVTrackSwap::ResizeVTrackSwap(ResizeVTrackWindow *gui,
 177         ResizeVTrackThread *thread,
 178         int x,
 179         int y)
 180  : BC_Button(x, y, thread->mwindow->theme->get_image_set("swap_extents"))
 181 {
 182         this->thread = thread;
 183         this->gui = gui;
 184         set_tooltip(_("Swap dimensions"));
 185 }
 186
 187 int ResizeVTrackSwap::handle_event()
 188 {
 189         int w = thread->w;
 190         int h = thread->h;
 191         thread->w = h;
 192         thread->h = w;
 193         gui->w->update((int64_t)h);
 194         gui->h->update((int64_t)w);
 195         gui->update(0, 1);
 196         return 1;
 197 }
 198
 199
 200
 201
 202
 203
 204 ResizeVTrackWidth::ResizeVTrackWidth(ResizeVTrackWindow *gui,
 205         ResizeVTrackThread *thread,
 206         int x,
 207         int y)
 208  : BC_TextBox(x, y, xS(90), 1, thread->w)
 209 {
 210         this->gui = gui;
 211         this->thread = thread;
 212 }
 213 int ResizeVTrackWidth::handle_event()
 214 {
 215         thread->w = atol(get_text());
 216         gui->update(0, 1);
 217         return 1;
 218 }
 219
 220 ResizeVTrackHeight::ResizeVTrackHeight(ResizeVTrackWindow *gui,
 221         ResizeVTrackThread *thread,
 222         int x,
 223         int y)
 224  : BC_TextBox(x, y, xS(90), 1, thread->h)
 225 {
 226         this->gui = gui;
 227         this->thread = thread;
 228 }
 229 int ResizeVTrackHeight::handle_event()
 230 {
 231         thread->h = atol(get_text());
 232         gui->update(0, 1);
 233         return 1;
 234 }
 235
 236
 237 ResizeVTrackScaleW::ResizeVTrackScaleW(ResizeVTrackWindow *gui,
 238         ResizeVTrackThread *thread,
 239         int x,
 240         int y)
 241  : BC_TextBox(x, y, xS(90), 1, (float)thread->w_scale)
 242 {
 243         this->gui = gui;
 244         this->thread = thread;
 245 }
 246 int ResizeVTrackScaleW::handle_event()
 247 {
 248         thread->w_scale = atof(get_text());
 249         gui->update(1, 0);
 250         return 1;
 251 }
 252
 253 ResizeVTrackScaleH::ResizeVTrackScaleH(ResizeVTrackWindow *gui,
 254         ResizeVTrackThread *thread,
 255         int x,
 256         int y)
 257  : BC_TextBox(x, y, xS(90), 1, (float)thread->h_scale)
 258 {
 259         this->gui = gui;
 260         this->thread = thread;
 261 }
 262 int ResizeVTrackScaleH::handle_event()
 263 {
 264         thread->h_scale = atof(get_text());
 265         gui->update(1, 0);
 266         return 1;
 267 }
 268
 269
 270 ResizeReset::ResizeReset(ResizeVTrackWindow *gui,
 271         ResizeVTrackThread *thread, int x, int y)
 272  : BC_Button(x, y, thread->mwindow->theme->get_image_set("reset_button"))
 273 {
 274         this->gui = gui;
 275         this->thread = thread;
 276         set_tooltip(_("Reset"));
 277 }
 278 int ResizeReset::handle_event()
 279 {
 280         thread->w = thread->w1;
 281         thread->h = thread->h1;
 282         thread->w_scale = 1;
 283         thread->h_scale = 1;
 284         gui->update(1, 1);
 285         return 1;
 286 }
 287
 288
 289
 290 ResizeTrackThread::ResizeTrackThread(MWindow *mwindow)
 291  : ResizeVTrackThread(mwindow)
 292 {
 293 }
 294
 295 ResizeTrackThread::~ResizeTrackThread()
 296 {
 297 }
 298
 299
 300 void ResizeTrackThread::start_window(Track *track)
 301 {
 302         this->track= track;
 303         ResizeVTrackThread::start_window(track->track_w,
 304                 track->track_h,
 305                 track->track_w,
 306                 track->track_h);
 307 }
 308
 309 void ResizeTrackThread::update()
 310 {
 311         if( mwindow->edl->tracks->track_exists(track) )
 312                 mwindow->resize_track(track, w, h);
 313 }
 314
 315
 316
 317
 318 ResizeAssetThread::ResizeAssetThread(AssetEditWindow *fwindow)
 319  : ResizeVTrackThread(fwindow->mwindow)
 320 {
 321         this->fwindow = fwindow;
 322 }
 323
 324 ResizeAssetThread::~ResizeAssetThread()
 325 {
 326 }
 327
 328 void ResizeAssetThread::start_window(Asset *asset)
 329 {
 330         this->asset = asset;
 331         ResizeVTrackThread::start_window(asset->get_w(),
 332                 asset->get_h(),
 333                 asset->actual_width,
 334                 asset->actual_height);
 335 }
 336
 337 void ResizeAssetThread::update()
 338 {
 339         char string[BCTEXTLEN];
 340         asset->width = w;
 341         asset->height = h;
 342         fwindow->lock_window("ResizeAssetThread::update");
 343         sprintf(string, "%d", asset->width);
 344         fwindow->win_width->update(string);
 345         sprintf(string, "%d", asset->height);
 346         fwindow->win_height->update(string);
 347         fwindow->unlock_window();
 348 }
 349
 350 ResizeAssetButton::ResizeAssetButton(AssetEditWindow *fwindow, int x, int y)
 351  : BC_GenericButton(x, y, _("Resize"))
 352 {
 353         resize_asset_thread = 0;
 354         this->fwindow = fwindow;
 355 }
 356
 357 ResizeAssetButton::~ResizeAssetButton()
 358 {
 359         delete resize_asset_thread;
 360 }
 361
 362 int ResizeAssetButton::handle_event()
 363 {
 364         if( !resize_asset_thread )
 365                 resize_asset_thread = new ResizeAssetThread(fwindow);
 366         resize_asset_thread->start_window(fwindow->asset_edit->changed_params);
 367         return 1;
 368 }
 369
 370