cinelerra-5.1/guicast/bclistbox.h

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #ifndef BCLISTBOX_H
  22 #define BCLISTBOX_H
  23
  24 #include "bcdragwindow.inc"
  25 #include "bclistboxitem.inc"
  26 #include "bcpixmap.inc"
  27 #include "bcscrollbar.h"
  28 #include "bcsubwindow.h"
  29 #include "bctoggle.h"
  30 #include "bccolors.h"
  31
  32 #define BCPOPUPLISTBOX_W 25
  33 #define BCPOPUPLISTBOX_H 25
  34
  35 class BC_ListBoxYScroll;
  36 class BC_ListBoxXScroll;
  37 class BC_ListBoxToggle;
  38 class BC_ListBox;
  39
  40 #define MIN_COLUMN_WIDTH 10
  41
  42
  43 class BC_ListBoxYScroll : public BC_ScrollBar
  44 {
  45         BC_ListBox *listbox;
  46 public:
  47         BC_ListBoxYScroll(BC_ListBox *listbox);
  48         ~BC_ListBoxYScroll();
  49         int handle_event();
  50 };
  51
  52 class BC_ListBoxXScroll : public BC_ScrollBar
  53 {
  54         BC_ListBox *listbox;
  55 public:
  56         BC_ListBoxXScroll(BC_ListBox *listbox);
  57         ~BC_ListBoxXScroll();
  58         int handle_event();
  59 };
  60
  61 class BC_ListBoxToggle
  62 {
  63 public:
  64         BC_ListBoxToggle(BC_ListBox *listbox, BC_ListBoxItem *item, int x, int y);
  65
  66         int cursor_motion_event(int *redraw_toggles);
  67         int cursor_leave_event(int *redraw_toggles);
  68         int button_press_event();
  69         int button_release_event(int *redraw_toggles);
  70         void update(BC_ListBoxItem *item, int x, int y, int flash);
  71         void draw(int flash);
  72
  73         BC_ListBox *listbox;
  74         BC_ListBoxItem *item;
  75         int x, y;
  76         int value, state;
  77         enum
  78         {
  79                 TOGGLE_UP,
  80                 TOGGLE_UPHI,
  81                 TOGGLE_CHECKED,
  82                 TOGGLE_DOWN,
  83                 TOGGLE_CHECKEDHI,
  84 // Button pressed then moved out
  85                 TOGGLE_DOWN_EXIT
  86         };
  87 };
  88
  89
  90 class BC_ListBox : public BC_SubWindow
  91 {
  92         friend class BC_ListBoxYScroll;
  93         friend class BC_ListBoxXScroll;
  94         friend class BC_ListBoxToggle;
  95 public:
  96         BC_ListBox(int x, int y, int w, int h,
  97                 int display_format,                   // Display text list or icons
  98                 ArrayList<BC_ListBoxItem*> *data = 0, // Each column has an ArrayList of BC_ListBoxItems.
  99                 const char **column_titles = 0,             // Titles for columns.  Set to 0 for no titles
 100                 int *column_width = 0,                // width of each column
 101                 int columns = 1,                      // Total columns.  Only 1 in icon mode
 102                 int yposition = 0,                    // Pixel of top of window.
 103                 int is_popup = 0,                     // If this listbox is a popup window with a button
 104                 int selection_mode = LISTBOX_SINGLE,  // Select one item or multiple items
 105                 int icon_position = ICON_LEFT,        // Position of icon relative to text of each item
 106                 int allow_drag = 0);                  // Allow user to drag icons around
 107         virtual ~BC_ListBox();
 108
 109         int initialize();
 110
 111 // User event handler for new selections
 112         virtual int selection_changed() { return 0; };
 113 // User event handler for triggering a selection
 114         virtual int handle_event() { return 0; };
 115 // User event handler for a column resize
 116         virtual int column_resize_event() { return 0; };
 117 // Draw background on bg_surface
 118         virtual void draw_background();
 119 // Draw on bg_surface
 120         virtual int draw_images() { return 0; }
 121 // Column sort order.  This must return 1 or BC_ListBox will perform a default
 122 // action.
 123         virtual int sort_order_event() { return 0; };
 124 // Column moved
 125         virtual int move_column_event() { return 0; };
 126 // item highlight changed
 127         virtual int mouse_over_event(int no) { return 0; }
 128
 129         int enable();
 130         int disable();
 131
 132 // Get the column movement
 133         int get_from_column();
 134         int get_to_column();
 135
 136 // Get the item in the given column which is the selection_number of the total
 137 // selected rows.  Returns 0 on failure.
 138         BC_ListBoxItem* get_selection(int column, int selection_number);
 139         BC_ListBoxItem* get_selection_recursive(ArrayList<BC_ListBoxItem*> *data,
 140                 int column,
 141                 int selection_number);
 142
 143 // Get the flat index of the item in the given column which is the selection_number
 144 // of the total selected rows.  Returns -1 on failure.  The column
 145 // argument is really useless because it only checks column 1 and returns the row
 146 // number.
 147         int get_selection_number(int column, int selection_number);
 148         int get_selection_number_recursive(ArrayList<BC_ListBoxItem*> *data,
 149                 int column,
 150                 int selection_number,
 151                 int *counter = 0);
 152
 153         virtual int evaluate_query(char *string);
 154         void expand_item(BC_ListBoxItem *item, int expand);
 155 // Collapse all items
 156         static void collapse_recursive(ArrayList<BC_ListBoxItem*> *data,
 157                 int master_column);
 158 // Convert recursive pointer to flat index.
 159 // The pointer can be any item in the row corresponding to the index.
 160 // Returns -1 if no item was found.
 161         int item_to_index(ArrayList<BC_ListBoxItem*> *data,
 162                 BC_ListBoxItem *item,
 163                 int *counter = 0);
 164 // Convert flat index and column to desired item.
 165         BC_ListBoxItem* index_to_item(ArrayList<BC_ListBoxItem*> *data,
 166                 int number,
 167                 int column,
 168                 int *counter = 0);
 169 // Get all items with recursion for text mode
 170         static int get_total_items(ArrayList<BC_ListBoxItem*> *data,
 171                 int *result /* = 0 */,
 172                 int master_column);
 173
 174         virtual int focus_out_event();
 175         virtual int keypress_event();
 176         virtual int button_press_event();
 177         virtual int button_release_event();
 178         virtual int cursor_enter_event();
 179         virtual int cursor_leave_event();
 180         virtual int cursor_motion_event();
 181         virtual int drag_start_event();
 182         virtual int drag_motion_event();
 183         virtual int drag_stop_event();
 184
 185 // After popping up a menu call this to interrupt the selection process
 186         void deactivate_selection();
 187
 188 // take_focus - used by the suggestion box to keep it from taking focus from the
 189 // textbox
 190         int activate(int take_focus = 1);
 191         int activate(int x, int y, int w=-1, int h=-1);
 192         int deactivate();
 193         int is_active();
 194         int expander_active();
 195
 196 // get item no at current cursor position
 197         int get_cursor_item_no();
 198 // get top data item no, and item at current cursor position
 199         int get_cursor_data_item_no(BC_ListBoxItem **item_return=0);
 200
 201         int translation_event();
 202         int repeat_event(int64_t duration);
 203         BC_DragWindow* get_drag_popup();
 204 // If the popup window should show a button.
 205 // Must be called in the constructor.
 206         void set_use_button(int value);
 207         void set_is_suggestions(int value);
 208         void set_scroll_repeat();
 209         void unset_scroll_repeat();
 210         int scroll_repeat;
 211
 212 // change the contents
 213         int update(ArrayList<BC_ListBoxItem*> *data,
 214                 const char **column_titles, int *column_widths, int columns,
 215                 int xposition = 0, int yposition = 0,
 216                 int highlighted_number = -1,  // Flat index of item cursor is over
 217                 int recalc_positions = 0,     // set all autoplace flags to 1
 218                 int draw = 1);
 219         void center_selection();
 220         void update_format(int display_format, int redraw);
 221         int get_format();
 222
 223 // Allow scrolling when dragging items
 224         void set_drag_scroll(int value);
 225 // Allow column repositioning
 226         void set_allow_drag_column(int value);
 227 // Allow automatic moving of objects after drag
 228         void set_process_drag(int value);
 229
 230 // Set the column to use for icons and sublists.
 231         void set_master_column(int value, int redraw);
 232 // Set column to search
 233         void set_search_column(int value);
 234         int set_selection_mode(int mode);
 235         int set_yposition(int position, int draw_items = 1);
 236         int get_yposition();
 237         int set_xposition(int position);
 238         int get_xposition();
 239 // Return the flat index of the highlighted item
 240         int get_highlighted_item();
 241         int get_yscroll_x();
 242         int get_yscroll_y();
 243         int get_yscroll_height();
 244         int get_xscroll_x();
 245         int get_xscroll_y();
 246         int get_xscroll_width();
 247         void set_scroll_stretch(int xv, int yv);
 248         int get_column_offset(int column);
 249         int get_column_width(int column, int clamp_right = 0);
 250         int get_title_h();
 251         int get_display_mode();
 252         void set_justify(int value);
 253         int get_w() { return is_popup ? BCPOPUPLISTBOX_W : popup_w; }
 254         int get_h() { return is_popup ? BCPOPUPLISTBOX_H : popup_h; }
 255         int gui_tooltip(const char *text) {
 256                 return is_popup && gui ? gui->show_tooltip(text, gui->get_w(),0, -1,-1) : -1;
 257         }
 258         int get_view_w() { return view_w; }
 259         int get_view_h() { return view_h; }
 260         int get_row_height() { return row_height; }
 261         int get_row_ascent() { return row_ascent; }
 262         int get_row_descent() { return row_descent; }
 263         int get_first_visible() { return first_in_view; }
 264         int get_last_visible() { return last_in_view; }
 265
 266         enum
 267         {
 268                 SORT_ASCENDING,
 269                 SORT_DESCENDING
 270         };
 271
 272         int get_sort_column();
 273         void set_sort_column(int value, int redraw = 0);
 274         int get_sort_order();
 275         void set_sort_order(int value, int redraw = 0);
 276
 277
 278         void reset_query();
 279         int get_show_query() { return show_query; }
 280         void set_show_query(int v) { show_query = v; }
 281
 282         int reposition_window(int x,
 283                 int y,
 284                 int w = -1,
 285                 int h = -1,
 286                 int flush = 1);
 287         BC_Pixmap* get_bg_surface();
 288 // Set all items for autoplacement with recursion into sublists
 289         void set_autoplacement(ArrayList<BC_ListBoxItem*> *data,
 290                 int do_icon,
 291                 int do_text);
 292 // Set selection status on all items with recursion
 293         void set_all_selected(ArrayList<BC_ListBoxItem*> *data, int value);
 294 // Set selection status of single row with recursion
 295 // item_number - the flat index of the row to select
 296         void set_selected(ArrayList<BC_ListBoxItem*> *data,
 297                 int item_number,
 298                 int value,
 299                 int *counter = 0);
 300
 301 // Called by keypress_event for cursor up.  Selects previous and next visible
 302 // row, skipping desired number of visible rows.
 303         int select_previous(int skip,
 304                 BC_ListBoxItem *selected_item = 0,
 305                 int *counter = 0,
 306                 ArrayList<BC_ListBoxItem*> *data = 0,
 307                 int *got_it = 0,
 308                 int *got_second = 0);
 309         int select_next(int skip,
 310                 BC_ListBoxItem *selected_item = 0,
 311                 int *counter = 0,
 312                 ArrayList<BC_ListBoxItem*> *data = 0,
 313                 int *got_it = 0,
 314                 int *got_second = 0);
 315
 316 // Called by cursor_motion_event to select different item if selection_number
 317 // changed.  Returns 1 if redraw is required.
 318         int update_selection(ArrayList<BC_ListBoxItem*> *data,
 319                 int selection_number,
 320                 int *counter = 0);
 321
 322         static void dump(ArrayList<BC_ListBoxItem*> *data,
 323                 int columns,
 324                 int indent /* = 0 */,
 325                 int master_column);
 326
 327         int get_icon_x(BC_ListBoxItem *item);
 328         int get_icon_y(BC_ListBoxItem *item);
 329         int get_icon_w(BC_ListBoxItem *item);
 330         int get_icon_h(BC_ListBoxItem *item);
 331         int get_text_w(BC_ListBoxItem *item);
 332         int get_text_h(BC_ListBoxItem *item);
 333         int get_item_x(BC_ListBoxItem *item);
 334         int get_item_y(BC_ListBoxItem *item);
 335         int get_item_w(BC_ListBoxItem *item);
 336         int get_item_h(BC_ListBoxItem *item);
 337
 338 // Draw the list items
 339         int draw_items(int flash, int bg_draw=0);
 340         int is_highlighted();
 341
 342 private:
 343         void delete_columns();
 344         void set_columns(const char **column_titles,
 345                 int *column_widths,
 346                 int columns);
 347 // Draw the button for a popup listbox
 348         int draw_button(int flush);
 349 // Draw list border
 350         int draw_border(int flash);
 351 // Draw column titles
 352         void draw_title(int number);
 353         int draw_titles(int flash);
 354 // Draw expanders
 355         void draw_toggles(int flash);
 356 // Draw selection rectangle
 357         int draw_rectangle(int flash);
 358
 359
 360         void draw_text_recursive(ArrayList<BC_ListBoxItem*> *data,
 361                 int column,
 362                 int indent,
 363                 int *current_toggle);
 364 // Returns 1 if selection changed
 365         int query_list();
 366         void init_column_width();
 367         void reset_cursor(int new_cursor);
 368 // Fix boundary conditions after resize
 369         void column_width_boundaries();
 370 // Recursive function to get the first item selected in text mode.
 371 // Returns > -1 only if it got it.  Always increments *result
 372         int get_first_selection(ArrayList<BC_ListBoxItem*> *data, int *result = 0);
 373 // Recursive function to get the last item selected in text mode.
 374 // Returns > -1 only if it got it.  Always increments *result
 375         int get_last_selection(ArrayList<BC_ListBoxItem*> *data, int *result = 0);
 376 // Called by button_press_event and cursor_motion_event to expand the selection.
 377 // Returns 1 if redraw is required.
 378         int expand_selection(int button_press, int selection_number);
 379 // Called by button_press_event and cursor_motion_event
 380 // to select a range in text mode
 381         void select_range(ArrayList<BC_ListBoxItem*> *data,
 382                 int start,
 383                 int end,
 384                 int *current = 0);
 385 // Called by button_press_event to toggle the selection status of a single item.
 386 // Called for both text and icon mode.  In text mode it's recursive and fills
 387 // the entire row with the first item's value.  Returns 1 when the item was toggled.
 388         int toggle_item_selection(ArrayList<BC_ListBoxItem*> *data,
 389                 int selection_number,
 390                 int *counter = 0);
 391 // Set value of selected in all selected items to new value
 392         void promote_selections(ArrayList<BC_ListBoxItem*> *data,
 393                 int old_value,
 394                 int new_value);
 395
 396
 397         int test_column_divisions(int cursor_x, int cursor_y, int &new_cursor);
 398         int test_column_titles(int cursor_x, int cursor_y);
 399         int test_expanders();
 400
 401         int calculate_item_coords();
 402         void calculate_last_coords_recursive(
 403                 ArrayList<BC_ListBoxItem*> *data,
 404                 int *icon_x,
 405                 int *next_icon_x,
 406                 int *next_icon_y,
 407                 int *next_text_y,
 408                 int top_level);
 409         void calculate_item_coords_recursive(
 410                 ArrayList<BC_ListBoxItem*> *data,
 411                 int *icon_x,
 412                 int *next_icon_x,
 413                 int *next_icon_y,
 414                 int *next_text_y,
 415                 int top_level);
 416
 417         int get_items_width();
 418         int get_items_height(ArrayList<BC_ListBoxItem*> *data,
 419                 int columns,
 420                 int *result = 0);
 421         int get_baseline(BC_ListBoxItem *item);
 422         int get_item_highlight(ArrayList<BC_ListBoxItem*> *data, int column, int item);
 423         int get_item_color(ArrayList<BC_ListBoxItem*> *data, int column, int item);
 424         int get_icon_mask(BC_ListBoxItem *item, int &x, int &y, int &w, int &h);
 425         int get_text_mask(BC_ListBoxItem *item, int &x, int &y, int &w, int &h);
 426 // Copy sections of the bg_surface to the gui
 427         void clear_listbox(int x, int y, int w, int h);
 428
 429 // Tests for cursor outside boundaries
 430         int test_drag_scroll(int cursor_x, int cursor_y);
 431 // Called by select_scroll_event, rectangle_scroll_event to execute for movement
 432         int drag_scroll_event();
 433         int select_scroll_event();
 434         int rectangle_scroll_event();
 435
 436
 437         void move_vertical(int pixels);
 438         void move_horizontal(int pixels);
 439         void clamp_positions();
 440
 441         int get_scrollbars();
 442         void update_scrollbars(int flush);
 443
 444 // Flat index of the item the cursor is over.
 445 // Points *item_return to the first item in the row or 0 if no item was found.
 446 // if it's nonzero.  Returns -1 if no item was found.  Clamps the y coordinate
 447 // only if the current operation is not SELECT, so scrolling is possible.
 448 // expanded = 1 if items in this table should be tested for cursor coverage
 449 // expanded = -1 returns only the top level master column index/item
 450         int get_cursor_item(ArrayList<BC_ListBoxItem*> *data,
 451                 int cursor_x,
 452                 int cursor_y,
 453                 BC_ListBoxItem **item_return = 0,
 454                 int *counter = 0,
 455                 int expanded = 1);
 456 // Select the items in the rectangle and deselect the items outside of it.
 457 // Returns 1 if redraw is required.
 458         int select_rectangle(ArrayList<BC_ListBoxItem*> *data,
 459                 int x1,
 460                 int y1,
 461                 int x2,
 462                 int y2);
 463 // Convert the row of the item to a pointer.
 464         BC_ListBoxItem* number_to_item(int row);
 465         int reposition_item(ArrayList<BC_ListBoxItem*> *data,
 466                 int selection_number,
 467                 int x,
 468                 int y,
 469                 int *counter = 0);
 470 // Move selected items to src_items
 471         void move_selection(ArrayList<BC_ListBoxItem*> *dst,
 472                 ArrayList<BC_ListBoxItem*> *src);
 473 // Put items from the src table into the data table starting at flat item number
 474 // destination.
 475         int put_selection(ArrayList<BC_ListBoxItem*> *data,
 476                 ArrayList<BC_ListBoxItem*> *src,
 477                 int destination,
 478                 int *counter = 0);
 479
 480         int center_selection(int selection,
 481                 ArrayList<BC_ListBoxItem*> *data = 0,
 482                 int *counter = 0);
 483
 484 // Array of one list of pointers for each column
 485         ArrayList<BC_ListBoxItem*> *data;
 486
 487
 488 // 1 if a button is used to make the listbox display
 489         int is_popup;      // popup
 490 // If the button for a popup should be shown
 491         int use_button;
 492 // background update needed
 493         int bg_draw;
 494
 495 // Dimensions for a popup if there is one
 496         int popup_w, popup_h;
 497 // pixel of top of display relative to top of list
 498         int yposition;
 499 // pixel of left display relative to first column
 500         int xposition;
 501 // dimensions of a row in the list
 502         int row_height, row_ascent, row_descent;
 503
 504
 505         int selection_mode;
 506         int display_format;
 507         int temp_display_format;
 508         int icon_position;
 509 // Scrollbars are created as needed
 510         BC_ListBoxXScroll *xscrollbar;
 511         BC_ListBoxYScroll *yscrollbar;
 512         ArrayList<BC_ListBoxToggle*> expanders;
 513         char query[BCTEXTLEN];
 514         int show_query;
 515
 516 // Window containing the listbox
 517         BC_WindowBase *gui;
 518         int disabled;
 519 // Size of the popup if there is one
 520         char **column_titles;
 521         int *column_width;
 522         int default_column_width[32];
 523         int columns;
 524         int master_column;
 525         int search_column;
 526
 527         int view_h, view_w;
 528         int first_in_view, last_in_view;
 529         int title_h;
 530 // Maximum width of items.  Calculated by get_items_width
 531         int items_w;
 532         int items_h;
 533 // In BCLISTBOX_SELECT mode determines the value to set items to
 534         int new_value;
 535         int need_xscroll, need_yscroll;
 536         int xscroll_orientation, yscroll_orientation;
 537 // Move items during drag operation of text items.
 538         int process_drag;
 539         int allow_drag;
 540         int allow_drag_scroll;
 541         int allow_drag_column;
 542 // Background color of listbox
 543         int list_background;
 544
 545
 546 // Popup button
 547         BC_Pixmap *button_images[4];
 548 // Expander
 549         BC_Pixmap *toggle_images[5];
 550 // Background for drawing on
 551         BC_Pixmap *bg_surface;
 552 // Background if 9 segment
 553         BC_Pixmap *bg_tile;
 554 // Drag icon for text mode
 555         VFrame *drag_icon_vframe;
 556 // Drag column icon
 557         VFrame *drag_column_icon_vframe;
 558 // Background picon to be drawn in the upper right
 559         BC_Pixmap *bg_pixmap;
 560
 561
 562 // Column title backgrounds
 563         BC_Pixmap *column_bg[3];
 564 // Column sort order
 565         BC_Pixmap *column_sort_up;
 566         BC_Pixmap *column_sort_dn;
 567
 568
 569
 570
 571 // Number of column to sort
 572         int sort_column;
 573 // Sort order.  -1 means no column is being sorted.
 574         int sort_order;
 575
 576
 577
 578
 579
 580 // State of the list box and button when the mouse button is pressed.
 581         int current_operation;
 582
 583         enum
 584         {
 585                 NO_OPERATION,
 586                 BUTTON_DOWN_SELECT, // Pressed button and slid off to select items.
 587                 BUTTON_DN,
 588                 DRAG_DIVISION,    // Dragging column division
 589                 DRAG_COLUMN,      // Dragging column
 590                 DRAG_ITEM,        // Dragging item
 591                 SELECT,                   // Select item
 592                 SELECT_RECT,      // Selection rectangle
 593                 WHEEL,                    // Wheel mouse
 594                 COLUMN_DN,                // column title down
 595                 COLUMN_DRAG,      // column title is being dragged
 596                 EXPAND_DN         // Expander is down
 597         };
 598
 599
 600 // More state variables
 601         int button_highlighted;
 602         int list_highlighted;
 603         int packed_icons;
 604 // item cursor is over.  May not exist in tables.
 605 // Must be an index since this is needed to change the database.
 606         int highlighted_item;
 607         BC_ListBoxItem* highlighted_ptr;
 608 // column title if the cursor is over a column title
 609         int highlighted_title;
 610 // Division the cursor is operating on when resizing
 611         int highlighted_division;
 612 // Column title being dragged
 613         int dragged_title;
 614 // start of column title drag
 615         int drag_cursor_x;
 616         int drag_column_w;
 617
 618 // Selection range being extended
 619         int selection_start, selection_end, selection_center;
 620 // Item being dragged or last item selected in a double click operation
 621         int selection_number;
 622 // Used in button_press_event and button_release_event to detect double clicks
 623         int selection_number1, selection_number2;
 624
 625
 626
 627
 628         int active;
 629 // Popup listboxes have different behavior for suggestion boxes where the
 630 // textbox needs to be active when the listbox is visible.
 631         int is_suggestions;
 632
 633 // Button release counter for double clicking
 634         int button_releases;
 635         int current_cursor;
 636 // Starting coordinates of rectangle
 637         int rect_x1, rect_y1;
 638         int rect_x2, rect_y2;
 639
 640
 641
 642 // Window for dragging
 643         BC_DragWindow *drag_popup;
 644         int justify;
 645 };
 646
 647
 648
 649
 650 #endif