cinelerra-5.1/cinelerra/zoompanel.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2014 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 "bcsignals.h"
  23 #include "clip.h"
  24 #include "edl.h"
  25 #include "edlsession.h"
  26 #include "mwindow.h"
  27 #include "mwindowgui.h"
  28 #include "theme.h"
  29 #include "trackcanvas.h"
  30 #include "units.h"
  31 #include "vframe.h"
  32 #include "zoompanel.h"
  33
  34
  35 ZoomHash::ZoomHash(double value, const char *text)
  36 {
  37         this->value = value;
  38         this->text = new char[strlen(text) + 1];
  39         strcpy(this->text, text);
  40 }
  41
  42 ZoomHash::~ZoomHash()
  43 {
  44         delete [] text;
  45 }
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63 ZoomPanel::ZoomPanel(MWindow *mwindow,
  64         BC_WindowBase *subwindow,
  65         double value,
  66         int x,
  67         int y,
  68         int w,
  69         double min,
  70         double max,
  71         int zoom_type)
  72 {
  73         this->mwindow = mwindow;
  74         this->subwindow = subwindow;
  75         this->x = x;
  76         this->y = y;
  77         this->w = w;
  78         this->value = value;
  79         this->min = min;
  80         this->max = max;
  81         this->zoom_type = zoom_type;
  82         this->menu_images = 0;
  83         this->tumbler_images = 0;
  84         this->user_table = 0;
  85         this->user_size = 0;
  86 }
  87
  88 ZoomPanel::ZoomPanel(MWindow *mwindow,
  89         BC_WindowBase *subwindow,
  90         double value,
  91         int x,
  92         int y,
  93         int w,
  94         double *user_table,
  95         int user_size,
  96         int zoom_type)
  97 {
  98         this->mwindow = mwindow;
  99         this->subwindow = subwindow;
 100         this->x = x;
 101         this->y = y;
 102         this->w = w;
 103         this->value = value;
 104         this->min = min;
 105         this->max = max;
 106         this->zoom_type = zoom_type;
 107         this->menu_images = 0;
 108         this->tumbler_images = 0;
 109         this->user_table = user_table;
 110         this->user_size = user_size;
 111 }
 112
 113 ZoomPanel::~ZoomPanel()
 114 {
 115         delete zoom_text;
 116         delete zoom_tumbler;
 117         zoom_table.remove_all_objects();
 118 }
 119
 120 void ZoomPanel::calculate_menu()
 121 {
 122         if(user_size)
 123         {
 124                 for(int i = 0; i < user_size; i++)
 125                 {
 126                         zoom_text->add_item(new BC_MenuItem(value_to_text(user_table[i], 0)));
 127                         zoom_table.append(new ZoomHash(user_table[i], value_to_text(user_table[i], 0)));
 128                 }
 129         }
 130         else
 131         {
 132                 for(double zoom = min; zoom <= max; zoom *= 2)
 133                 {
 134                         zoom_text->add_item(new BC_MenuItem(value_to_text(zoom, 0)));
 135                         zoom_table.append(new ZoomHash(zoom, value_to_text(zoom, 0)));
 136                 }
 137         }
 138 }
 139
 140 int ZoomPanel::calculate_w(int menu_w)
 141 {
 142         return BC_PopupMenu::calculate_w(menu_w) + BC_Tumbler::calculate_w();
 143 }
 144
 145 void ZoomPanel::update_menu()
 146 {
 147         while(zoom_text->total_items()) zoom_text->del_item(0);
 148
 149         zoom_table.remove_all_objects();
 150         calculate_menu();
 151 }
 152
 153 void ZoomPanel::set_menu_images(VFrame **data)
 154 {
 155         this->menu_images = data;
 156 }
 157
 158 void ZoomPanel::set_tumbler_images(VFrame **data)
 159 {
 160         this->tumbler_images = data;
 161 }
 162
 163 void ZoomPanel::create_objects()
 164 {
 165         subwindow->add_subwindow(zoom_text = new ZoomPopup(mwindow,
 166                 this,
 167                 x,
 168                 y));
 169         x += zoom_text->get_w();
 170         subwindow->add_subwindow(zoom_tumbler = new ZoomTumbler(mwindow,
 171                 this,
 172                 x,
 173                 y));
 174         calculate_menu();
 175 }
 176
 177 void ZoomPanel::reposition_window(int x, int y)
 178 {
 179         zoom_text->reposition_window(x, y);
 180         x += zoom_text->get_w();
 181         zoom_tumbler->reposition_window(x, y);
 182 }
 183
 184
 185 int ZoomPanel::get_w()
 186 {
 187         return zoom_text->get_w() + zoom_tumbler->get_w();
 188 }
 189
 190 double ZoomPanel::get_value()
 191 {
 192         return value;
 193 }
 194
 195 char* ZoomPanel::get_text()
 196 {
 197         return zoom_text->get_text();
 198 }
 199
 200 void ZoomPanel::set_text(const char *text)
 201 {
 202         zoom_text->set_text(text);
 203 }
 204
 205 void ZoomPanel::update(double value)
 206 {
 207         this->value = value;
 208         zoom_text->set_text(value_to_text(value));
 209 }
 210
 211 void ZoomPanel::update(const char *value)
 212 {
 213         zoom_text->set_text(value);
 214 }
 215
 216
 217 char* ZoomPanel::value_to_text(double value, int use_table)
 218 {
 219         if(use_table)
 220         {
 221                 for(int i = 0; i < zoom_table.total; i++)
 222                 {
 223 //printf("ZoomPanel::value_to_text %p\n", zoom_table.values[i]);
 224                         if(EQUIV(zoom_table.values[i]->value, value))
 225                                 return zoom_table.values[i]->text;
 226                 }
 227 //printf("ZoomPanel::value_to_text: should never get here\n");
 228                 return zoom_table.values[0]->text;
 229         }
 230
 231         switch(zoom_type)
 232         {
 233                 case ZOOM_PERCENTAGE:
 234                         sprintf(string, "%d%%", (int)(value * 100));
 235                         break;
 236
 237                 case ZOOM_FLOAT:
 238                         sprintf(string, "%.1f", value);
 239                         break;
 240
 241                 case ZOOM_LONG:
 242                         sprintf(string, "%ld", (long)value);
 243                         break;
 244
 245                 case ZOOM_TIME:
 246                 {
 247 //                      sprintf(string, "%ld", (long)value);
 248                         double total_seconds = (double)(mwindow->theme->mcanvas_w -
 249                                         mwindow->theme->patchbay_w -
 250                                         BC_ScrollBar::get_span(SCROLL_VERT)) *
 251                                 value /
 252                                 mwindow->edl->session->sample_rate;
 253                         Units::totext(string,
 254                                 total_seconds,
 255                                 mwindow->edl->session->time_format,
 256                                 mwindow->edl->session->sample_rate,
 257                                 mwindow->edl->session->frame_rate,
 258                                 mwindow->edl->session->frames_per_foot);
 259                         break;
 260                 }
 261         }
 262         return string;
 263 }
 264
 265 double ZoomPanel::text_to_zoom(char *text, int use_table)
 266 {
 267         if(use_table) {
 268                 for(int i = 0; i < zoom_table.total; i++) {
 269                         if(!strcasecmp(text, zoom_table.values[i]->text))
 270                                 return zoom_table.values[i]->value;
 271                 }
 272                 return zoom_table.values[0]->value;
 273         }
 274
 275         double result = 1.;
 276         switch(zoom_type) {
 277                 case ZOOM_PERCENTAGE:
 278                         result = atof(text) / 100;
 279                         break;
 280                 case ZOOM_FLOAT:
 281                 case ZOOM_LONG:
 282 //              case ZOOM_TIME:
 283                         result = atof(text);
 284                         break;
 285                 case ZOOM_TIME: {
 286                         double total_samples = Units::fromtext(text,
 287                                 mwindow->edl->session->sample_rate,
 288                                 mwindow->edl->session->time_format,
 289                                 mwindow->edl->session->frame_rate,
 290                                 mwindow->edl->session->frames_per_foot);
 291                         total_samples /= mwindow->theme->mcanvas_w -
 292                                 mwindow->theme->patchbay_w -
 293                                 BC_ScrollBar::get_span(SCROLL_VERT);
 294                         double difference = fabs(total_samples - result);
 295                         while(fabs(result - total_samples) <= difference) {
 296                                 difference = fabs(result - total_samples);
 297                                 result *= 2;
 298                         }
 299                         break;
 300                 }
 301         }
 302         return result;
 303 }
 304
 305
 306
 307
 308
 309
 310
 311 ZoomPopup::ZoomPopup(MWindow *mwindow, ZoomPanel *panel, int x, int y)
 312  : BC_PopupMenu(x,
 313                 y,
 314                 panel->w,
 315                 panel->value_to_text(panel->value, 0),
 316                 1,
 317                 panel->menu_images)
 318 {
 319         this->mwindow = mwindow;
 320         this->panel = panel;
 321 }
 322
 323 ZoomPopup::~ZoomPopup()
 324 {
 325 }
 326
 327 int ZoomPopup::handle_event()
 328 {
 329         panel->value = panel->text_to_zoom(get_text());
 330         panel->handle_event();
 331         return 1;
 332 }
 333
 334
 335
 336 ZoomTumbler::ZoomTumbler(MWindow *mwindow, ZoomPanel *panel, int x, int y)
 337  : BC_Tumbler(x,
 338         y,
 339         panel->tumbler_images)
 340 {
 341         this->mwindow = mwindow;
 342         this->panel = panel;
 343 }
 344
 345 ZoomTumbler::~ZoomTumbler()
 346 {
 347 }
 348
 349 int ZoomTumbler::handle_up_event()
 350 {
 351         if(panel->user_table)
 352         {
 353                 int current_index = 0;
 354                 for(current_index = 0; current_index < panel->user_size; current_index++)
 355                         if(EQUIV(panel->user_table[current_index], panel->value)) break;
 356                 current_index++;
 357                 CLAMP(current_index, 0, panel->user_size - 1);
 358                 panel->value = panel->user_table[current_index];
 359         }
 360         else
 361         {
 362                 panel->value *= 2;
 363                 RECLIP(panel->value, panel->min, panel->max);
 364         }
 365
 366         panel->zoom_text->set_text(panel->value_to_text(panel->value));
 367         panel->handle_event();
 368         return 1;
 369 }
 370
 371 int ZoomTumbler::handle_down_event()
 372 {
 373         if(panel->user_table)
 374         {
 375                 int current_index = 0;
 376                 for(current_index = 0; current_index < panel->user_size; current_index++)
 377                         if(EQUIV(panel->user_table[current_index], panel->value)) break;
 378                 current_index--;
 379                 CLAMP(current_index, 0, panel->user_size - 1);
 380                 panel->value = panel->user_table[current_index];
 381         }
 382         else
 383         {
 384                 panel->value /= 2;
 385                 RECLIP(panel->value, panel->min, panel->max);
 386         }
 387         panel->zoom_text->set_text(panel->value_to_text(panel->value));
 388         panel->handle_event();
 389         return 1;
 390 }