guicast/bcscrollbar.C

   1 #include "bcpixmap.h"
   2 #include "bcresources.h"
   3 #include "bcscrollbar.h"
   4 #include "clip.h"
   5 #include "colors.h"
   6 #include "vframe.h"
   7
   8 #include <string.h>
   9
  10 BC_ScrollBar::BC_ScrollBar(int x,
  11         int y,
  12         int orientation,
  13         int pixels,
  14         int64_t length,
  15         int64_t position,
  16         int64_t handlelength,
  17         VFrame **data)
  18  : BC_SubWindow(x, y, 0, 0, -1)
  19 {
  20         this->length = length;
  21         this->position = position;
  22         this->handlelength = handlelength;
  23         this->selection_status = 0;
  24         this->highlight_status = 0;
  25         this->orientation = orientation;
  26         this->pixels = pixels;
  27
  28         if(data)
  29                 this->data = data;
  30         else
  31         if(orientation == SCROLL_HORIZ)
  32                 this->data = BC_WindowBase::get_resources()->hscroll_data;
  33         else
  34                 this->data = BC_WindowBase::get_resources()->vscroll_data;
  35
  36         handle_pixel = 0;
  37         handle_pixels = 0;
  38         bound_to = 0;
  39         repeat_count = 0;
  40         memset(images, 0, sizeof(BC_Pixmap*) * SCROLL_IMAGES);
  41 }
  42
  43 BC_ScrollBar::~BC_ScrollBar()
  44 {
  45         for(int i = 0; i < SCROLL_IMAGES; i++)
  46                 if(images[i]) delete images[i];
  47 }
  48
  49 int BC_ScrollBar::initialize()
  50 {
  51 //printf("BC_ScrollBar::initialize 1\n");
  52         set_images(data);
  53 //printf("BC_ScrollBar::initialize 1\n");
  54
  55         BC_SubWindow::initialize();
  56 //printf("BC_ScrollBar::initialize 1\n");
  57         draw();
  58         return 0;
  59 }
  60
  61 void BC_ScrollBar::set_images(VFrame **data)
  62 {
  63         for(int i = 0; i < SCROLL_IMAGES; i++)
  64         {
  65                 if(images[i]) delete images[i];
  66                 images[i] = new BC_Pixmap(parent_window, data[i], PIXMAP_ALPHA);
  67 //printf("BC_ScrollBar::set_images %d %p\n", i, data[i]);
  68         }
  69         calculate_dimensions(w, h);
  70 }
  71
  72
  73
  74 void BC_ScrollBar::calculate_dimensions(int &w, int &h)
  75 {
  76         switch(orientation)
  77         {
  78                 case SCROLL_HORIZ:
  79                         w = pixels;
  80                         h = data[SCROLL_HANDLE_UP]->get_h();
  81                         break;
  82
  83                 case SCROLL_VERT:
  84                         w = data[SCROLL_HANDLE_UP]->get_w();
  85                         h = pixels;
  86                         break;
  87         }
  88 }
  89
  90 int BC_ScrollBar::get_span(int orientation)
  91 {
  92         switch(orientation)
  93         {
  94                 case SCROLL_HORIZ:
  95                         return BC_WindowBase::get_resources()->hscroll_data[SCROLL_HANDLE_UP]->get_h();
  96                         break;
  97
  98                 case SCROLL_VERT:
  99                         return BC_WindowBase::get_resources()->vscroll_data[SCROLL_HANDLE_UP]->get_w();
 100                         break;
 101         }
 102         return 0;
 103 }
 104
 105 int BC_ScrollBar::get_span()
 106 {
 107         switch(orientation)
 108         {
 109                 case SCROLL_HORIZ:
 110                         return data[SCROLL_HANDLE_UP]->get_h();
 111                         break;
 112
 113                 case SCROLL_VERT:
 114                         return data[SCROLL_HANDLE_UP]->get_w();
 115                         break;
 116         }
 117         return 0;
 118 }
 119
 120 int BC_ScrollBar::get_arrow_pixels()
 121 {
 122         switch(orientation)
 123         {
 124                 case SCROLL_HORIZ:
 125                         return data[SCROLL_BACKARROW_UP]->get_w();
 126                         break;
 127
 128                 case SCROLL_VERT:
 129                         return data[SCROLL_BACKARROW_UP]->get_h();
 130                         break;
 131         }
 132         return 0;
 133 }
 134
 135
 136 void BC_ScrollBar::draw()
 137 {
 138         draw_top_background(parent_window, 0, 0, w, h);
 139         get_handle_dimensions();
 140
 141         switch(orientation)
 142         {
 143                 case SCROLL_HORIZ:
 144
 145
 146 //printf("BC_ScrollBar::draw 1 %d %d\n", selection_status, highlight_status == SCROLL_BACKARROW);
 147 // Too small to draw anything
 148                         if(get_w() < get_arrow_pixels() * 2 + 5)
 149                         {
 150                                 draw_3segmenth(0,
 151                                         0,
 152                                         get_w(),
 153                                         images[SCROLL_HANDLE_UP]);
 154                         }
 155                         else
 156                         {
 157
 158
 159
 160
 161 // back arrow
 162 //printf("BC_ScrollBar::draw 2 %p\n", images[SCROLL_BACKARROW_HI]);
 163                                 if(selection_status == SCROLL_BACKARROW)
 164                                         draw_pixmap(images[SCROLL_BACKARROW_DN],
 165                                                 0,
 166                                                 0);
 167                                 else
 168                                 if(highlight_status == SCROLL_BACKARROW)
 169                                         draw_pixmap(images[SCROLL_BACKARROW_HI],
 170                                                 0,
 171                                                 0);
 172                                 else
 173                                         draw_pixmap(images[SCROLL_BACKARROW_UP],
 174                                                 0,
 175                                                 0);
 176 //printf("BC_ScrollBar::draw 2\n");
 177
 178
 179
 180
 181
 182
 183 // forward arrow
 184                                 if(selection_status == SCROLL_FWDARROW)
 185                                         draw_pixmap(images[SCROLL_FWDARROW_DN],
 186                                                 get_w() - get_arrow_pixels(),
 187                                                 0);
 188                                 else
 189                                 if(highlight_status == SCROLL_FWDARROW)
 190                                         draw_pixmap(images[SCROLL_FWDARROW_HI],
 191                                                 get_w() - get_arrow_pixels(),
 192                                                 0);
 193                                 else
 194                                         draw_pixmap(images[SCROLL_FWDARROW_UP],
 195                                                 get_w() - get_arrow_pixels(),
 196                                                 0);
 197
 198
 199
 200
 201
 202 //printf("BC_ScrollBar::draw 2\n");
 203
 204 // handle background
 205                                 draw_3segmenth(get_arrow_pixels(),
 206                                         0,
 207                                         handle_pixel - get_arrow_pixels(),
 208                                         images[SCROLL_HANDLE_BG]);
 209
 210 // handle foreground
 211 //printf("BC_ScrollBar::draw 2 %d %d\n", handle_pixel, handle_pixels);
 212                                 if(selection_status == SCROLL_HANDLE)
 213                                         draw_3segmenth(handle_pixel,
 214                                                 0,
 215                                                 handle_pixels,
 216                                                 images[SCROLL_HANDLE_DN]);
 217                                 else
 218                                 if(highlight_status == SCROLL_HANDLE)
 219                                         draw_3segmenth(handle_pixel,
 220                                                 0,
 221                                                 handle_pixels,
 222                                                 images[SCROLL_HANDLE_HI]);
 223                                 else
 224                                         draw_3segmenth(handle_pixel,
 225                                                 0,
 226                                                 handle_pixels,
 227                                                 images[SCROLL_HANDLE_UP]);
 228 //printf("BC_ScrollBar::draw 2\n");
 229
 230 // handle background
 231                                 draw_3segmenth(handle_pixel + handle_pixels,
 232                                         0,
 233                                         get_w() - get_arrow_pixels() - handle_pixel - handle_pixels,
 234                                         images[SCROLL_HANDLE_BG]);
 235 //printf("BC_ScrollBar::draw 3 %d %d\n", handle_pixel, handle_pixels);
 236                         }
 237                         break;
 238
 239
 240
 241
 242
 243
 244
 245
 246                 case SCROLL_VERT:
 247 // Too small to draw anything
 248                         if(get_h() < get_arrow_pixels() * 2 + 5)
 249                         {
 250                                 draw_3segmentv(0,
 251                                         0,
 252                                         get_w(),
 253                                         images[SCROLL_HANDLE_UP]);
 254                         }
 255                         else
 256                         {
 257
 258
 259
 260
 261 // back arrow
 262 //printf("BC_ScrollBar::draw 2 %p\n", images[SCROLL_BACKARROW_HI]);
 263                                 if(selection_status == SCROLL_BACKARROW)
 264                                         draw_pixmap(images[SCROLL_BACKARROW_DN],
 265                                                 0,
 266                                                 0);
 267                                 else
 268                                 if(highlight_status == SCROLL_BACKARROW)
 269                                         draw_pixmap(images[SCROLL_BACKARROW_HI],
 270                                                 0,
 271                                                 0);
 272                                 else
 273                                         draw_pixmap(images[SCROLL_BACKARROW_UP],
 274                                                 0,
 275                                                 0);
 276 //printf("BC_ScrollBar::draw 2\n");
 277
 278
 279
 280
 281
 282
 283 // forward arrow
 284                                 if(selection_status == SCROLL_FWDARROW)
 285                                         draw_pixmap(images[SCROLL_FWDARROW_DN],
 286                                                 0,
 287                                                 get_h() - get_arrow_pixels());
 288                                 else
 289                                 if(highlight_status == SCROLL_FWDARROW)
 290                                         draw_pixmap(images[SCROLL_FWDARROW_HI],
 291                                                 0,
 292                                                 get_h() - get_arrow_pixels());
 293                                 else
 294                                         draw_pixmap(images[SCROLL_FWDARROW_UP],
 295                                                 0,
 296                                                 get_h() - get_arrow_pixels());
 297
 298
 299
 300
 301
 302 //printf("BC_ScrollBar::draw 2\n");
 303
 304 // handle background
 305                                 draw_3segmentv(0,
 306                                         get_arrow_pixels(),
 307                                         handle_pixel - get_arrow_pixels(),
 308                                         images[SCROLL_HANDLE_BG]);
 309
 310 // handle foreground
 311 //printf("BC_ScrollBar::draw 2 %d %d\n", handle_pixel, handle_pixels);
 312                                 if(selection_status == SCROLL_HANDLE)
 313                                         draw_3segmentv(0,
 314                                                 handle_pixel,
 315                                                 handle_pixels,
 316                                                 images[SCROLL_HANDLE_DN]);
 317                                 else
 318                                 if(highlight_status == SCROLL_HANDLE)
 319                                         draw_3segmentv(0,
 320                                                 handle_pixel,
 321                                                 handle_pixels,
 322                                                 images[SCROLL_HANDLE_HI]);
 323                                 else
 324                                         draw_3segmentv(0,
 325                                                 handle_pixel,
 326                                                 handle_pixels,
 327                                                 images[SCROLL_HANDLE_UP]);
 328 //printf("BC_ScrollBar::draw 2\n");
 329
 330 // handle background
 331                                 draw_3segmentv(0,
 332                                         handle_pixel + handle_pixels,
 333                                         get_h() - get_arrow_pixels() - handle_pixel - handle_pixels,
 334                                         images[SCROLL_HANDLE_BG]);
 335 //printf("BC_ScrollBar::draw 3 %d %d\n", handle_pixel, handle_pixels);
 336                         }
 337                         break;
 338         }
 339         flash();
 340 }
 341
 342 void BC_ScrollBar::get_handle_dimensions()
 343 {
 344         int total_pixels = pixels -
 345                 get_arrow_pixels() * 2;
 346
 347         if(length > 0)
 348         {
 349                 handle_pixels = (int64_t)((double)handlelength /
 350                         length *
 351                         total_pixels +
 352                         .5);
 353
 354                 if(handle_pixels < get_resources()->scroll_minhandle)
 355                         handle_pixels = get_resources()->scroll_minhandle;
 356
 357
 358                 handle_pixel = (int64_t)((double)position /
 359                                 length *
 360                                 total_pixels + .5) +
 361                         get_arrow_pixels();
 362
 363 // Handle pixels is beyond minimum right position.  Clamp it.
 364                 if(handle_pixel > pixels - get_arrow_pixels() - get_resources()->scroll_minhandle)
 365                 {
 366                         handle_pixel = pixels - get_arrow_pixels() - get_resources()->scroll_minhandle;
 367                         handle_pixels = get_resources()->scroll_minhandle;
 368                 }
 369 // Shrink handle_pixels until it fits inside scrollbar
 370                 if(handle_pixel > pixels - get_arrow_pixels() - handle_pixels)
 371                 {
 372                         handle_pixels = pixels - get_arrow_pixels() - handle_pixel;
 373                 }
 374                 if(handle_pixel < get_arrow_pixels())
 375                 {
 376                         handle_pixels = handle_pixel + handle_pixels - get_arrow_pixels();
 377                         handle_pixel = get_arrow_pixels();
 378                 }
 379                 if(handle_pixels < get_resources()->scroll_minhandle) handle_pixels = get_resources()->scroll_minhandle;
 380         }
 381         else
 382         {
 383                 handle_pixels = total_pixels;
 384                 handle_pixel = get_arrow_pixels();
 385         }
 386
 387         CLAMP(handle_pixel, get_arrow_pixels(), (int)(pixels - get_arrow_pixels()));
 388         CLAMP(handle_pixels, 0, total_pixels);
 389
 390 // printf("BC_ScrollBar::get_handle_dimensions %d %d %d\n",
 391 // total_pixels,
 392 // handle_pixel,
 393 // handle_pixels);
 394 }
 395
 396 int BC_ScrollBar::cursor_enter_event()
 397 {
 398         if(top_level->event_win == win)
 399         {
 400                 if(!highlight_status)
 401                 {
 402                         highlight_status = get_cursor_zone(top_level->cursor_x,
 403                                 top_level->cursor_y);
 404                         draw();
 405                 }
 406                 return 1;
 407         }
 408         return 0;
 409 }
 410
 411 int BC_ScrollBar::cursor_leave_event()
 412 {
 413         if(highlight_status)
 414         {
 415                 highlight_status = 0;
 416                 draw();
 417         }
 418         return 0;
 419 }
 420
 421 int BC_ScrollBar::cursor_motion_event()
 422 {
 423         if(top_level->event_win == win)
 424         {
 425                 if(highlight_status && !selection_status)
 426                 {
 427                         int new_highlight_status =
 428                                 get_cursor_zone(top_level->cursor_x, top_level->cursor_y);
 429                         if(new_highlight_status != highlight_status)
 430                         {
 431                                 highlight_status = new_highlight_status;
 432                                 draw();
 433                         }
 434                 }
 435                 else
 436                 if(selection_status == SCROLL_HANDLE)
 437                 {
 438 //printf("BC_ScrollBar::cursor_motion_event 1\n");
 439                         double total_pixels = pixels - get_arrow_pixels() * 2;
 440                         int64_t cursor_pixel = (orientation == SCROLL_HORIZ) ?
 441                                 top_level->cursor_x :
 442                                 top_level->cursor_y;
 443                         int64_t new_position = (int64_t)((double)(cursor_pixel - min_pixel) /
 444                                 total_pixels * length);
 445 //printf("BC_ScrollBar::cursor_motion_event 2\n");
 446
 447                         if(new_position > length - handlelength)
 448                                 new_position = length - handlelength;
 449                         if(new_position < 0) new_position = 0;
 450
 451                         if(new_position != position)
 452                         {
 453 //printf("BC_ScrollBar::cursor_motion_event 3\n");
 454                                 position = new_position;
 455                                 draw();
 456                                 handle_event();
 457 //printf("BC_ScrollBar::cursor_motion_event 4\n");
 458                         }
 459                 }
 460                 return 1;
 461         }
 462         return 0;
 463 }
 464
 465 int BC_ScrollBar::button_press_event()
 466 {
 467         if(top_level->event_win == win)
 468         {
 469                 if(!bound_to)
 470                 {
 471                         top_level->deactivate();
 472                         activate();
 473                 }
 474
 475                 if(get_buttonpress() == 4)
 476                 {
 477                         selection_status = SCROLL_BACKARROW;
 478                         repeat_event(top_level->get_resources()->scroll_repeat);
 479                 }
 480                 else
 481                 if(get_buttonpress() == 5)
 482                 {
 483                         selection_status = SCROLL_FWDARROW;
 484                         repeat_count = 0;
 485                         repeat_event(top_level->get_resources()->scroll_repeat);
 486                 }
 487                 else
 488                 {
 489                         selection_status = get_cursor_zone(top_level->cursor_x, top_level->cursor_y);
 490                         if(selection_status == SCROLL_HANDLE)
 491                         {
 492                                 double total_pixels = pixels - get_arrow_pixels() * 2;
 493                                 int64_t cursor_pixel = (orientation == SCROLL_HORIZ) ? top_level->cursor_x : top_level->cursor_y;
 494                                 min_pixel = cursor_pixel - (int64_t)((double)position / length * total_pixels + .5);
 495                                 max_pixel = (int)(cursor_pixel + total_pixels);
 496                                 draw();
 497                         }
 498                         else
 499                         if(selection_status)
 500                         {
 501                                 top_level->set_repeat(top_level->get_resources()->scroll_repeat);
 502                                 repeat_count = 0;
 503                                 repeat_event(top_level->get_resources()->scroll_repeat);
 504                                 draw();
 505                         }
 506                 }
 507                 return 1;
 508         }
 509         return 0;
 510 }
 511
 512 int BC_ScrollBar::repeat_event(int64_t duration)
 513 {
 514         if(duration == top_level->get_resources()->scroll_repeat &&
 515                 selection_status)
 516         {
 517                 repeat_count++;
 518                 if(repeat_count == 2) return 0;
 519                 int64_t new_position = position;
 520                 switch(selection_status)
 521                 {
 522                         case SCROLL_BACKPAGE:
 523                                 new_position -= handlelength;
 524                                 break;
 525                         case SCROLL_FWDPAGE:
 526                                 new_position += handlelength;
 527                                 break;
 528                         case SCROLL_BACKARROW:
 529                                 new_position -= handlelength / 10;
 530                                 break;
 531                         case SCROLL_FWDARROW:
 532                                 new_position += handlelength / 10;
 533                                 break;
 534                 }
 535
 536                 if(new_position > length - handlelength) new_position = length - handlelength;
 537                 if(new_position < 0) new_position = 0;
 538                 if(new_position != position)
 539                 {
 540                         position = new_position;
 541                         draw();
 542                         handle_event();
 543                 }
 544                 return 1;
 545         }
 546         return 0;
 547 }
 548
 549 int BC_ScrollBar::button_release_event()
 550 {
 551 //printf("BC_ScrollBar::button_release_event %d\n", selection_status);
 552         if(selection_status)
 553         {
 554                 if(selection_status != SCROLL_HANDLE)
 555                         top_level->unset_repeat(top_level->get_resources()->scroll_repeat);
 556
 557                 selection_status = 0;
 558                 draw();
 559                 return 1;
 560         }
 561         return 0;
 562 }
 563
 564 int BC_ScrollBar::get_cursor_zone(int cursor_x, int cursor_y)
 565 {
 566         if(orientation == SCROLL_VERT)
 567         {
 568                 cursor_x ^= cursor_y;
 569                 cursor_y ^= cursor_x;
 570                 cursor_x ^= cursor_y;
 571         }
 572
 573
 574
 575         if(cursor_x >= pixels - get_arrow_pixels())
 576                 return SCROLL_FWDARROW;
 577         else
 578         if(cursor_x >= get_arrow_pixels())
 579         {
 580                 if(cursor_x > handle_pixel + handle_pixels)
 581                         return SCROLL_FWDPAGE;
 582                 else
 583                 if(cursor_x >= handle_pixel)
 584                         return SCROLL_HANDLE;
 585                 else
 586                         return SCROLL_BACKPAGE;
 587         }
 588         else
 589                 return SCROLL_BACKARROW;
 590
 591
 592
 593
 594         return 0;
 595 }
 596
 597 int BC_ScrollBar::activate()
 598 {
 599         top_level->active_subwindow = this;
 600 //printf("BC_ScrollBar::activate %p %p\n", top_level->active_subwindow, this);
 601         return 0;
 602 }
 603
 604 int64_t BC_ScrollBar::get_value()
 605 {
 606         return position;
 607 }
 608
 609 int64_t BC_ScrollBar::get_position()
 610 {
 611         return position;
 612 }
 613
 614 int64_t BC_ScrollBar::get_length()
 615 {
 616         return length;
 617 }
 618
 619 int BC_ScrollBar::get_pixels()
 620 {
 621         return pixels;
 622 }
 623
 624 int BC_ScrollBar::in_use()
 625 {
 626         return selection_status != 0;
 627 }
 628
 629 int64_t BC_ScrollBar::get_handlelength()
 630 {
 631         return handlelength;
 632 }
 633
 634 int BC_ScrollBar::update_value(int64_t value)
 635 {
 636         this->position = value;
 637         draw();
 638         return 0;
 639 }
 640
 641 int BC_ScrollBar::update_length(int64_t length, int64_t position, int64_t handlelength)
 642 {
 643         this->length = length;
 644         this->position = position;
 645         this->handlelength = handlelength;
 646         draw();
 647         return 0;
 648 }
 649
 650 int BC_ScrollBar::reposition_window(int x, int y, int pixels)
 651 {
 652         if(x != get_x() || y != get_y() || pixels != this->pixels)
 653         {
 654                 this->pixels = pixels;
 655                 int new_w, new_h;
 656                 calculate_dimensions(new_w, new_h);
 657                 BC_WindowBase::reposition_window(x, y, new_w, new_h);
 658         }
 659         draw();
 660         return 0;
 661 }
 662
 663 /*
 664 //      Local Variables:
 665 //      mode: C++
 666 //      c-file-style: "linux"
 667 //      End:
 668 */