1 // widget-helper.h
2 // LiVES
3 // (c) G. Finch 2012 - 2015 <salsaman@gmail.com>
4 // released under the GNU GPL 3 or later
5 // see file ../COPYING or www.gnu.org for licensing details
6
7 // this is kind of a fun project.
8 // a) for me to learn more C++
9 // b) to experiment with another widget toolkit
10 // c) to make LiVES a little less dependent on GKT+
11
12
13 #ifndef HAS_LIVES_WIDGET_HELPER_QT_H
14 #define HAS_LIVES_WIDGET_HELPER_QT_H
15
16 #ifdef GUI_QT
17 // just for testing !!!!
18
19
20 #ifdef HAVE_X11
21 #include <X11/Xlib.h>
22 #endif
23
24 using namespace std;
25
26 #include <QtCore/QLinkedList>
27
28 #include <QtGui/QScreen>
29 #include <QtGui/QWindow>
30 #include <QtGui/QTextCursor>
31 #include <QtGui/QTextDocumentFragment>
32 #include <QtGui/QShortcutEvent>
33 #include <QtGui/QWheelEvent>
34 #include <QtGui/QImageWriter>
35 #include <QtGui/QImageReader>
36 #include <QtCore/QDebug>
37 #include <QtCore/QTime>
38 #include <QtGui/QFont>
39 #include <QtGui/QFontDatabase>
40 #include <QtCore/QStandardPaths>
41 #include <QtCore/QLocale>
42 #include <QtCore/QMutableLinkedListIterator>
43
44 #include <QtWidgets/QApplication>
45 #include <QtWidgets/QDesktopWidget>
46 #include <QtWidgets/QCompleter>
47 #include <QtWidgets/QLabel>
48 #include <QtWidgets/QColorDialog>
49 #include <QtWidgets/QWidget>
50 #include <QtWidgets/QWidgetAction>
51 #include <QtWidgets/QStyledItemDelegate>
52 #include <QtWidgets/QHeaderView>
53 #include <QtWidgets/QSplitter>
54 #include <QtWidgets/QLineEdit>
55 #include <QtWidgets/QPushButton>
56 #include <QtWidgets/QToolButton>
57 #include <QtWidgets/QToolBar>
58 #include <QtWidgets/QTableWidget>
59 #include <QtWidgets/QDialog>
60 #include <QtWidgets/QMessageBox>
61 #include <QtWidgets/QDialogButtonBox>
62 #include <QtWidgets/QBoxLayout>
63 #include <QtWidgets/QComboBox>
64 #include <QtWidgets/QMenu>
65 #include <QtWidgets/QMenuBar>
66 #include <QtWidgets/QLabel>
67 #include <QtWidgets/QMainWindow>
68 #include <QtWidgets/QFileDialog>
69 #include <QtWidgets/QLayout>
70 #include <QtWidgets/QTextEdit>
71 #include <QtWidgets/QTreeWidget>
72 #include <QtWidgets/QRadioButton>
73 #include <QtWidgets/QButtonGroup>
74 #include <QtWidgets/QProgressBar>
75 #include <QtWidgets/QDoubleSpinBox>
76 #include <QtWidgets/QCheckBox>
77 #include <QtWidgets/QShortcut>
78 #include <QtWidgets/QGridLayout>
79 #include <QtWidgets/QFrame>
80 #include <QtWidgets/QGroupBox>
81 #include <QtWidgets/QScrollArea>
82 #include <QtWidgets/QScrollBar>
83
84 #include <QtGui/QColor>
85 #include <QtCore/QAbstractItemModel>
86 #include <QtWidgets/QAbstractSlider>
87 #include <QtWidgets/QAbstractButton>
88 #include <QtCore/QSharedPointer>
89 #include <QtGui/QStandardItemModel>
90 #include <QtCore/QModelIndex>
91 #include <QtCore/QTimer>
92 #include <QtCore/QThread>
93 #include <QtCore/QProcess>
94 #include <QtCore/QAbstractNativeEventFilter>
95 #include <QtCore/QCoreApplication>
96
97 QApplication *qapp;
98 QTime *qtime;
99
100 #define GTK_CHECK_VERSION(a,b,c) 1
101
102 #define LIVES_LITTLE_ENDIAN 0
103 #define LIVES_BIG_ENDIAN 1
104
105 #define LIVES_MAXINT INT_MAX
106 #define LIVES_MAXUINT32 UINT32_MAX
107 #define LIVES_MAXSIZE SIZE_MAX
108 #define LIVES_MAXFLOAT FLT_MAX
109
110 #define LIVES_UNLIKELY(a) Q_UNLIKELY(a)
111 #define LIVES_LIKELY(a) Q_LIKELY(a)
112
113 #define MAX_CURSOR_WIDTH 32
114
115 #define G_GNUC_MALLOC
116 #define G_GNUC_PURE
117 #define G_GNUC_CONST
118
119 typedef void *livespointer;
120 typedef const void *livesconstpointer;
121
122 #define LIVES_INT_TO_POINTER(a) lives_int_to_pointer(a)
123 #define LIVES_UINT_TO_POINTER(a) lives_uint_to_pointer(a)
124 #define LIVES_POINTER_TO_INT(a) lives_pointer_to_int(a)
125
lives_int_to_pointer(int32_t a)126 LIVES_INLINE livespointer lives_int_to_pointer(int32_t a) {
127 return (livespointer)a;
128 }
129
lives_uint_to_pointer(uint32_t a)130 LIVES_INLINE livespointer lives_uint_to_pointer(uint32_t a) {
131 return (livespointer)a;
132 }
133
lives_pointer_to_int(livesconstpointer p)134 LIVES_INLINE int32_t lives_pointer_to_int(livesconstpointer p) {
135 uint64_t xint = (uint64_t)p;
136 return (int32_t)(xint & 0xFFFF);
137 }
138
139 typedef struct {
140 livespointer(*malloc)(size_t n_bytes);
141 livespointer(*realloc)(livespointer mem,
142 size_t n_bytes);
143 void (*free)(livespointer mem);
144 /* optional; set to NULL if not used ! */
145 livespointer(*calloc)(size_t n_blocks,
146 size_t n_block_bytes);
147 livespointer(*try_malloc)(size_t n_bytes);
148 livespointer(*try_realloc)(livespointer mem,
149 size_t n_bytes);
150 } LiVESMemVTable;
151
152 LiVESMemVTable *static_alt_vtable;
153
154 void (*lives_free)(livespointer ptr);
155 livespointer(*lives_malloc)(size_t size);
156 livespointer(*lives_realloc)(livespointer ptr, size_t new_size);
157 livespointer(*lives_try_malloc)(size_t size);
158 livespointer(*lives_try_realloc)(livespointer ptr, size_t new_size);
159 livespointer(_lives_calloc)(size_t n_blocks, size_t n_block_bytes);
160
161
malloc_wrapper(size_t size)162 livespointer malloc_wrapper(size_t size) {
163 livespointer ptr = (static_alt_vtable->malloc)(size);
164 Q_ASSERT(ptr != NULL);
165 return ptr;
166 }
167
168
realloc_wrapper(livespointer old_ptr,size_t new_size)169 livespointer realloc_wrapper(livespointer old_ptr, size_t new_size) {
170 livespointer ptr = (static_alt_vtable->realloc)(old_ptr, new_size);
171 Q_ASSERT(ptr != NULL);
172 return ptr;
173 }
174
175
try_malloc_wrapper(size_t size)176 livespointer try_malloc_wrapper(size_t size) {
177 return (static_alt_vtable->malloc)(size);
178 }
179
180
try_realloc_wrapper(livespointer old_ptr,size_t new_size)181 livespointer try_realloc_wrapper(livespointer old_ptr, size_t new_size) {
182 return (static_alt_vtable->realloc)(old_ptr, new_size);
183 }
184
185
lives_malloc0(size_t size)186 LIVES_INLINE livespointer lives_malloc0(size_t size) {
187 livespointer ptr = (static_alt_vtable->calloc)(1, size);
188 Q_ASSERT(ptr != NULL);
189 return ptr;
190 }
191
192
lives_try_malloc0(size_t size)193 LIVES_INLINE livespointer lives_try_malloc0(size_t size) {
194 return (static_alt_vtable->calloc)(1, size);
195 }
196
197
lives_try_malloc0_n(size_t nmemb,size_t nmemb_bytes)198 LIVES_INLINE livespointer lives_try_malloc0_n(size_t nmemb, size_t nmemb_bytes) {
199 return (static_alt_vtable->calloc)(nmemb, nmemb_bytes);
200 }
201
202
203
204 #define NO_GTK
205 #include "support.h"
206
207 extern char *trString;
208
209 // TODO - move to support.c
translate(const char * String)210 char *translate(const char *String) {
211 delete trString; // be very careful, as trString is free()d automatically here
212 if (strlen(String)) {
213 QString qs = QString::fromLocal8Bit(dgettext(PACKAGE, String));
214 trString = strdup(qs.toUtf8().constData());
215 } else trString = strdup(String);
216 return trString;
217 }
218
translate_with_plural(const char * String,const char * StringPlural,unsigned long int n)219 char *translate_with_plural(const char *String, const char *StringPlural, unsigned long int n) {
220 delete trString; // be very careful, as trString is free()d automatically here
221 if (strlen(String)) {
222 QString qs = QString::fromLocal8Bit(dngettext(PACKAGE, String, StringPlural, n));
223 trString = strdup(qs.toUtf8().constData());
224 } else trString = strdup(String);
225 return trString;
226 }
227
228
lives_printerr(const char * format,...)229 int lives_printerr(const char *format, ...) {
230 char *buff;
231 va_list args;
232 va_start(args, format);
233 int r = vasprintf(&buff, format, args);
234 va_end(args);
235 qDebug() << buff;
236 free(buff);
237 return r;
238 }
239
240
241
242 #define lives_strdup(a) strdup(a)
243 #define lives_strndup(a,b) strndup(a,b)
244
lives_strdup_printf(const char * format,...)245 char *lives_strdup_printf(const char *format, ...) {
246 char *buff;
247 va_list args;
248 va_start(args, format);
249 int r = vasprintf(&buff, format, args);
250 r = r;
251 va_end(args);
252 return buff;
253 }
254
lives_snprintf(char * buff,size_t len,const char * format,...)255 int lives_snprintf(char *buff, size_t len, const char *format, ...) {
256 va_list args;
257 va_start(args, format);
258 int r = vsnprintf(buff, len, format, args);
259 va_end(args);
260 return r;
261 }
262
263
lives_strfreev(char ** str_array)264 void lives_strfreev(char **str_array) {
265 if (str_array) {
266 for (int i = 0; str_array[i] != NULL; i++)
267 lives_free(str_array[i]);
268 lives_free(str_array);
269 }
270 }
271
272 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
273 #define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
274
lives_ascii_strcasecmp(const char * s1,const char * s2)275 int lives_ascii_strcasecmp(const char *s1, const char *s2) {
276 int c1, c2;
277
278 while (*s1 && *s2) {
279 c1 = (int)(uint8_t) TOLOWER(*s1);
280 c2 = (int)(uint8_t) TOLOWER(*s2);
281 if (c1 != c2)
282 return (c1 - c2);
283 s1++;
284 s2++;
285 }
286 return (((int)(uint8_t) * s1) - ((int)(uint8_t) * s2));
287 }
288
289
lives_ascii_strncasecmp(const char * s1,const char * s2,size_t len)290 int lives_ascii_strncasecmp(const char *s1, const char *s2, size_t len) {
291 int c1, c2;
292
293 while (len && *s1 && *s2) {
294 len--;
295 c1 = (int)(uint8_t) TOLOWER(*s1);
296 c2 = (int)(uint8_t) TOLOWER(*s2);
297 if (c1 != c2)
298 return (c1 - c2);
299 s1++;
300 s2++;
301 }
302 if (len) return (((int)(uint8_t) * s1) - ((int)(uint8_t) * s2));
303 else return 0;
304 }
305
306
lives_strconcat(const char * string1,...)307 char *lives_strconcat(const char *string1, ...) {
308 size_t l;
309 va_list args;
310 char *s;
311 char *concat;
312 char *ptr;
313 if (!string1)
314 return NULL;
315 l = 1 + strlen(string1);
316 va_start(args, string1);
317 s = va_arg(args, char *);
318 while (s) {
319 l += strlen(s);
320 s = va_arg(args, char *);
321 }
322 va_end(args);
323 concat = (char *)malloc(l);
324 ptr = concat;
325 ptr = stpcpy(ptr, string1);
326 va_start(args, string1);
327 s = va_arg(args, char *);
328 while (s) {
329 ptr = stpcpy(ptr, s);
330 s = va_arg(args, char *);
331 }
332 va_end(args);
333 return concat;
334 }
335
336
337
lives_build_filename(const char * first,...)338 char *lives_build_filename(const char *first, ...) {
339 char *fname = strdup(""), *tmp;
340 char *piece;
341 char sep = '/';
342 va_list args;
343
344 #ifdef IS_MINGW
345 va_start(args, first);
346 while (1) {
347 piece = va_arg(args, char *);
348 if (piece == NULL) break;
349 if (strstr(piece, "\\")) {
350 sep = '\\';
351 break;
352 }
353 }
354 va_end(args);
355 #endif
356
357 va_start(args, first);
358 while (1) {
359 piece = va_arg(args, char *);
360 if (piece == NULL) break;
361 tmp = lives_strdup_printf("%s%s%s", fname, sep, piece);
362 lives_free(fname);
363 fname = tmp;
364 }
365 va_end(args);
366
367 QString qs(fname);
368 lives_free(fname);
369 #ifdef IS_MINGW
370 fname = strdup(QDir::cleanPath(qs).toUtf8().constData());
371 #else
372 fname = strdup(QDir::cleanPath(qs).toLocal8Bit().constData());
373 #endif
374 return fname;
375 }
376
377
lives_strstrip(char * string)378 char *lives_strstrip(char *string) {
379 QString qs = QString::fromUtf8(string);
380 qs.trimmed();
381 memcpy(string, qs.toUtf8().constData(), qs.toUtf8().size());
382 return string;
383 }
384
385
lives_strrstr(const char * haystack,const char * needle)386 char *lives_strrstr(const char *haystack, const char *needle) {
387 size_t i;
388 size_t needle_len;
389 size_t haystack_len;
390 const char *p;
391 needle_len = strlen(needle);
392 haystack_len = strlen(haystack);
393 if (needle_len == 0)
394 return (char *)haystack;
395 if (haystack_len < needle_len)
396 return NULL;
397 p = haystack + haystack_len - needle_len;
398 while (p >= haystack) {
399 for (i = 0; i < needle_len; i++)
400 if (p[i] != needle[i])
401 goto next;
402 return (char *)p;
403 next:
404 p--;
405 }
406 return NULL;
407 }
408
409
410
lives_filename_to_utf8(const char * ostr,ssize_t len,size_t * bytes_read,size_t * bytes_written,void * error)411 LIVES_INLINE char *lives_filename_to_utf8(const char *ostr, ssize_t len, size_t *bytes_read, size_t *bytes_written,
412 void *error) {
413 #ifndef IS_MINGW
414 QString qs = QString::fromLocal8Bit(ostr);
415 return strdup(qs.toUtf8().constData());
416 #endif
417 return strdup(ostr);
418 }
419
420
lives_filename_from_utf8(const char * ostr,ssize_t len,size_t * bytes_read,size_t * bytes_written,void * error)421 LIVES_INLINE char *lives_filename_from_utf8(const char *ostr, ssize_t len, size_t *bytes_read, size_t *bytes_written,
422 void *error) {
423 #ifndef IS_MINGW
424 QString qs = QString::fromUtf8(ostr);
425 return strdup(qs.toLocal8Bit().constData());
426 #endif
427 return strdup(ostr);
428 }
429
430
L2U8(const char * local_string)431 char *L2U8(const char *local_string) {
432 #ifndef IS_MINGW
433 QString qs = QString::fromLocal8Bit(local_string);
434 return strdup(qs.toUtf8().constData());
435 #else
436 return local_string;
437 #endif
438 }
439
U82L(const char * utf8_string)440 char *U82L(const char *utf8_string) {
441 #ifndef IS_MINGW
442 QString qs = QString::fromUtf8(utf8_string);
443 return strdup(qs.toLocal8Bit().constData());
444 #else
445 return utf8_string;
446 #endif
447 }
448
449
lives_utf8_strdown(char * string,size_t len)450 char *lives_utf8_strdown(char *string, size_t len) {
451 QString qs = QString::fromUtf8(string);
452 qs.toLower();
453 return strdup(qs.toUtf8().constData());
454 }
455
456
457
458 #define ABS(a) qAbs(a)
459
460
lives_find_program_in_path(const char * prog)461 char *lives_find_program_in_path(const char *prog) {
462 QString qs = QStandardPaths::findExecutable(prog);
463 if (qs == "") return NULL;
464 return strdup(qs.toLocal8Bit().constData());
465 }
466
467
468
469
470
471
472 #ifndef IS_MINGW
473 typedef bool boolean;
474 #endif
475
476
477 typedef boolean(*LiVESWidgetSourceFunc)(livespointer data);
478
479 typedef int (*LiVESCompareFunc)(livesconstpointer a, livesconstpointer b);
480
481 #ifndef FALSE
482 #define FALSE false
483 #endif
484
485 #ifndef TRUE
486 #define TRUE true
487 #endif
488
489
490 extern "C" {
491 uint32_t lives_timer_add(uint32_t interval, LiVESWidgetSourceFunc function, livespointer data);
492 }
493
494 #define G_PRIORITY_LOW 0
495 #define G_PRIORITY_HIGH 1
496
lives_idle_add_full(int prio,LiVESWidgetSourceFunc function,livespointer data,livespointer destnot)497 LIVES_INLINE uint32_t lives_idle_add_full(int prio, LiVESWidgetSourceFunc function, livespointer data, livespointer destnot) {
498 return lives_timer_add(0, function, data);
499 }
500
501
lives_idle_add(LiVESWidgetSourceFunc function,livespointer data)502 LIVES_INLINE uint32_t lives_idle_add(LiVESWidgetSourceFunc function, livespointer data) {
503 return lives_timer_add(0, function, data);
504 }
505
506 /// TODO
507 #define g_object_freeze_notify(a) (a)
508 #define g_object_thaw_notify(a) (a)
509
510
lives_set_application_name(const char * name)511 LIVES_INLINE void lives_set_application_name(const char *name) {
512 qapp->setApplicationName(QString::fromUtf8(name));
513 }
514
515
lives_get_application_name()516 LIVES_INLINE const char *lives_get_application_name() {
517 return qapp->applicationName().toLocal8Bit().constData();
518 }
519
520
521 class SleeperThread : public QThread {
522 public:
msleep(unsigned long msecs)523 static void msleep(unsigned long msecs) {
524 QThread::msleep(msecs);
525 }
526 };
527
lives_usleep(ulong microsec)528 LIVES_INLINE void lives_usleep(ulong microsec) {
529 SleeperThread::msleep(microsec);
530 }
531
532
lives_mkdir_with_parents(const char * name,int mode)533 LIVES_INLINE int lives_mkdir_with_parents(const char *name, int mode) {
534 #ifndef IS_MINGW
535 mode_t omask = umask(mode);
536 #endif
537 QString qs = QString::fromUtf8(name);
538 QDir qd = QDir(qs);
539 bool ret = qd.mkpath(qs);
540 #ifndef IS_MINGW
541 umask(omask);
542 #endif
543 if (!ret) return -1;
544 return 0;
545 }
546
547 #define lives_strtod(a,b) strtod(a,b)
548
lives_path_get_basename(const char * path)549 char *lives_path_get_basename(const char *path) {
550 QFileInfo qf(path);
551 QString qs = qf.fileName();
552 return strdup(qs.toUtf8().constData());
553 }
554
lives_path_get_dirname(const char * path)555 char *lives_path_get_dirname(const char *path) {
556 QFileInfo qf(path);
557 QDir dir = qf.dir();
558 QString qs = dir.path();
559 return strdup(qs.toUtf8().constData());
560 }
561
562
563 typedef int LiVESFileTest;
564 #define LIVES_FILE_TEST_EXISTS 1
565 #define LIVES_FILE_TEST_IS_DIR 2
566 #define LIVES_FILE_TEST_IS_REGULAR 3
567
568
lives_file_test(const char * fname,LiVESFileTest test)569 boolean lives_file_test(const char *fname, LiVESFileTest test) {
570 QFileInfo qf(fname);
571 if (test == LIVES_FILE_TEST_EXISTS) {
572 return qf.exists();
573 }
574 if (test == LIVES_FILE_TEST_IS_DIR) {
575 return qf.isDir();
576 }
577 if (test == LIVES_FILE_TEST_IS_REGULAR) {
578 return qf.isFile();
579 }
580 return FALSE;
581 }
582
583
lives_get_current_dir()584 char *lives_get_current_dir() {
585 QString qs = QDir::current().path();
586 #ifdef IS_MINGW
587 return strdup(qs.toUtf8().constData());
588 #else
589 return strdup(qs.toLocal8Bit().constData());
590 #endif
591
592 }
593
594 typedef struct {
595 ulong function;
596 livespointer data;
597 } LiVESClosure;
598
599 typedef LiVESClosure LiVESWidgetClosure;
600
601
602
603 //////////////////
604
605
606 typedef void (*LiVESPixbufDestroyNotify)(uchar *, livespointer);
607
608
609 typedef int lives_painter_content_t;
610
611
612
613 typedef struct {
614 int code;
615 char *message;
616 } LiVESError;
617
618
lives_error_free(LiVESError * error)619 LIVES_INLINE void lives_error_free(LiVESError *error) {
620 if (error->message != NULL) free(error->message);
621 free(error);
622 }
623
624 #define lives_strerror(a) strerror(a)
625
626
627 typedef QScreen LiVESXScreen;
628 typedef QScreen LiVESXDisplay;
629 typedef QScreen LiVESXDevice;
630
631 #ifndef HAVE_X11
632 typedef WId Window;
633 #endif
634
635 typedef QFile LiVESIOChannel;
636
637
638
639 //#define LIVES_TABLE_IS_GRID 1 // no "remove row" available
640
641
642
643 typedef QStyle::StateFlag LiVESWidgetState;
644
645 #define LIVES_WIDGET_STATE_NORMAL QStyle::State_Enabled
646 #define LIVES_WIDGET_STATE_ACTIVE QStyle::State_Active
647 #define LIVES_WIDGET_STATE_PRELIGHT QStyle::State_MouseOver
648 #define LIVES_WIDGET_STATE_SELECTED QStyle::State_Selected
649
650 #define LIVES_WIDGET_STATE_INSENSITIVE QStyle::State_None
651
652 #define LIVES_WIDGET_STATE_FOCUSED QStyle::State_HasFocus
653
654 //#define LIVES_WIDGET_STATE_INCONSISTENT GTK_STATE_FLAG_INCONSISTENT
655 //#define LIVES_WIDGET_STATE_BACKDROP GTK_STATE_FLAG_BACKDROP
656
657 #define LIVES_WIDGET_COLOR_HAS_ALPHA (1)
658 #define LIVES_WIDGET_COLOR_SCALE(x) (x) ///< macro to get 0. to 1.
659 #define LIVES_WIDGET_COLOR_SCALE_255(x) ((double)x/255.) ///< macro to convert from (0. - 255.) to component
660
661
662 typedef Qt::KeyboardModifiers LiVESXModifierType;
663
664 #define LIVES_CONTROL_MASK Qt::ControlModifier
665 #define LIVES_ALT_MASK Qt::AltModifier
666 #define LIVES_SHIFT_MASK Qt::ShiftModifier
667 #define LIVES_LOCK_MASK Qt::ShiftModifier
668
669
670 #define LIVES_KEY_Left (static_cast<uint32_t>(Qt::Key_Left))
671 #define LIVES_KEY_Right (static_cast<uint32_t>(Qt::Key_Right))
672 #define LIVES_KEY_Up (static_cast<uint32_t>(Qt::Key_Up))
673 #define LIVES_KEY_Down (static_cast<uint32_t>(Qt::Key_Down))
674
675 #define LIVES_KEY_BackSpace (static_cast<uint32_t>(Qt::Key_Backspace))
676 #define LIVES_KEY_Return (static_cast<uint32_t>(Qt::Key_Return))
677 #define LIVES_KEY_Tab (static_cast<uint32_t>(Qt::Key_Tab))
678 #define LIVES_KEY_Home (static_cast<uint32_t>(Qt::Key_Home))
679 #define LIVES_KEY_End (static_cast<uint32_t>(Qt::Key_End))
680 #define LIVES_KEY_Slash (static_cast<uint32_t>(Qt::Key_Slash))
681 #define LIVES_KEY_Space (static_cast<uint32_t>(Qt::Key_Space))
682 #define LIVES_KEY_Plus (static_cast<uint32_t>(Qt::Key_Plus))
683 #define LIVES_KEY_Minus (static_cast<uint32_t>(Qt::Key_Minus))
684 #define LIVES_KEY_Equal (static_cast<uint32_t>(Qt::Key_Equal))
685
686 #define LIVES_KEY_1 (static_cast<uint32_t>(Qt::Key_1))
687 #define LIVES_KEY_2 (static_cast<uint32_t>(Qt::Key_2))
688 #define LIVES_KEY_3 (static_cast<uint32_t>(Qt::Key_3))
689 #define LIVES_KEY_4 (static_cast<uint32_t>(Qt::Key_4))
690 #define LIVES_KEY_5 (static_cast<uint32_t>(Qt::Key_5))
691 #define LIVES_KEY_6 (static_cast<uint32_t>(Qt::Key_6))
692 #define LIVES_KEY_7 (static_cast<uint32_t>(Qt::Key_7))
693 #define LIVES_KEY_8 (static_cast<uint32_t>(Qt::Key_8))
694 #define LIVES_KEY_9 (static_cast<uint32_t>(Qt::Key_9))
695 #define LIVES_KEY_0 (static_cast<uint32_t>(Qt::Key_0))
696
697 #define LIVES_KEY_a (static_cast<uint32_t>(Qt::Key_A))
698 #define LIVES_KEY_b (static_cast<uint32_t>(Qt::Key_B))
699 #define LIVES_KEY_c (static_cast<uint32_t>(Qt::Key_C))
700 #define LIVES_KEY_d (static_cast<uint32_t>(Qt::Key_D))
701 #define LIVES_KEY_e (static_cast<uint32_t>(Qt::Key_E))
702 #define LIVES_KEY_f (static_cast<uint32_t>(Qt::Key_F))
703 #define LIVES_KEY_g (static_cast<uint32_t>(Qt::Key_G))
704 #define LIVES_KEY_h (static_cast<uint32_t>(Qt::Key_H))
705 #define LIVES_KEY_i (static_cast<uint32_t>(Qt::Key_I))
706 #define LIVES_KEY_j (static_cast<uint32_t>(Qt::Key_J))
707 #define LIVES_KEY_k (static_cast<uint32_t>(Qt::Key_K))
708 #define LIVES_KEY_l (static_cast<uint32_t>(Qt::Key_L))
709 #define LIVES_KEY_m (static_cast<uint32_t>(Qt::Key_M))
710 #define LIVES_KEY_n (static_cast<uint32_t>(Qt::Key_N))
711 #define LIVES_KEY_o (static_cast<uint32_t>(Qt::Key_O))
712 #define LIVES_KEY_p (static_cast<uint32_t>(Qt::Key_P))
713 #define LIVES_KEY_q (static_cast<uint32_t>(Qt::Key_Q))
714 #define LIVES_KEY_r (static_cast<uint32_t>(Qt::Key_R))
715 #define LIVES_KEY_s (static_cast<uint32_t>(Qt::Key_S))
716 #define LIVES_KEY_t (static_cast<uint32_t>(Qt::Key_T))
717 #define LIVES_KEY_u (static_cast<uint32_t>(Qt::Key_U))
718 #define LIVES_KEY_v (static_cast<uint32_t>(Qt::Key_V))
719 #define LIVES_KEY_w (static_cast<uint32_t>(Qt::Key_W))
720 #define LIVES_KEY_x (static_cast<uint32_t>(Qt::Key_X))
721 #define LIVES_KEY_y (static_cast<uint32_t>(Qt::Key_Y))
722 #define LIVES_KEY_z (static_cast<uint32_t>(Qt::Key_Z))
723
724 #define LIVES_KEY_F1 (static_cast<uint32_t>(Qt::Key_F1))
725 #define LIVES_KEY_F2 (static_cast<uint32_t>(Qt::Key_F2))
726 #define LIVES_KEY_F3 (static_cast<uint32_t>(Qt::Key_F3))
727 #define LIVES_KEY_F4 (static_cast<uint32_t>(Qt::Key_F4))
728 #define LIVES_KEY_F5 (static_cast<uint32_t>(Qt::Key_F5))
729 #define LIVES_KEY_F6 (static_cast<uint32_t>(Qt::Key_F6))
730 #define LIVES_KEY_F7 (static_cast<uint32_t>(Qt::Key_F7))
731 #define LIVES_KEY_F8 (static_cast<uint32_t>(Qt::Key_F8))
732 #define LIVES_KEY_F9 (static_cast<uint32_t>(Qt::Key_F9))
733 #define LIVES_KEY_F10 (static_cast<uint32_t>(Qt::Key_F10))
734 #define LIVES_KEY_F11 (static_cast<uint32_t>(Qt::Key_F11))
735 #define LIVES_KEY_F12 (static_cast<uint32_t>(Qt::Key_F12))
736
737 #define LIVES_KEY_Page_Up (static_cast<uint32_t>(Qt::Key_PageUp))
738 #define LIVES_KEY_Page_Down (static_cast<uint32_t>(Qt::Key_PageDown))
739
740 #define LIVES_KEY_Escape (static_cast<uint32_t>(Qt::Key_Escape))
741
742 typedef int LiVESAccelFlags;
743
744 typedef class LiVESAccelGroup LiVESAccelGroup;
745 typedef class LiVESWidget LiVESWidget;
746
747
748 typedef void LiVESXEvent;
749 typedef void LiVESXXEvent;
750 typedef void LiVESXEventMotion;
751 typedef void LiVESXEventFocus;
752
753 typedef QCursor LiVESXCursor;
754
755
756 #define LIVES_SCROLL_UP 1
757 #define LIVES_SCROLL_DOWN 2
758
759 typedef struct {
760 int direction;
761 LiVESXModifierType state;
762 } LiVESXEventScroll;
763
764
765 typedef struct {
766 int x;
767 int y;
768 int width;
769 int height;
770 } LiVESRect;
771
772
773 typedef struct {
774 int count;
775 LiVESRect area;
776 } LiVESXEventExpose;
777
778
779 typedef struct {
780 int time;
781 int type;
782 int button;
783 } LiVESXEventButton;
784
785 #define LIVES_BUTTON_PRESS 1
786 #define LIVES_BUTTON_RELEASE 2
787 #define LIVES_BUTTON2_PRESS 3
788
789
790 typedef void LiVESXEventCrossing;
791 typedef void LiVESXEventConfigure;
792 typedef void LiVESXEventDelete;
793
794
795 typedef class LiVESWidgetObject LiVESWidgetObject;
796
797 typedef void (*LiVESWidgetCallback)(LiVESWidget *widget, livespointer data);
798
lives_cclosure_new(ulong func,livespointer data,livespointer dest_func)799 LiVESClosure *lives_cclosure_new(ulong func, livespointer data, livespointer dest_func) {
800 LiVESClosure *cl = new LiVESClosure;
801 cl->function = (ulong)func;
802 cl->data = data;
803
804 return cl;
805 // TODO - something with dest_func: decref this when removed from accel, and call dest_func
806 }
807
808 typedef boolean(*LiVESScrollEventCallback)(LiVESWidget *widget, LiVESXEventScroll *, livespointer data);
809 typedef boolean(*LiVESExposeEventCallback)(LiVESWidget *widget, LiVESXEventExpose *, livespointer data);
810 typedef boolean(*LiVESEnterEventCallback)(LiVESWidget *widget, LiVESXEventCrossing *, livespointer data);
811 typedef boolean(*LiVESButtonEventCallback)(LiVESWidget *widget, LiVESXEventButton *, livespointer data);
812 typedef boolean(*LiVESConfigureEventCallback)(LiVESWidget *widget, LiVESXEventConfigure *, livespointer data);
813 typedef boolean(*LiVESDeleteEventCallback)(LiVESWidget *widget, LiVESXEventDelete *, livespointer data);
814 typedef boolean(*LiVESAccelCallback)(LiVESAccelGroup *group, LiVESWidgetObject *obj, uint32_t keyval, LiVESXModifierType mod,
815 livespointer data);
816
817 #define LIVES_GUI_CALLBACK(a) (ulong)(a)
818
819
820 typedef void LiVESTargetEntry;
821
822 typedef bool LiVESFilterReturn;
823
824 #define LIVES_FILTER_REMOVE true
825 #define LIVES_FILTER_CONTINUE false
826
827
828 typedef struct {
829 ulong handler_id; // set for signals, 0 for key accels
830 QKeySequence ks; // set for key accels
831 LiVESAccelFlags flags;
832 LiVESAccelGroup *group;
833 QShortcut *shortcut; // created for key accels
834
835 // for key accels, one or the other of these: - either we emit accel_signal, or we call closure
836 // for normal signals, both are set (name of signal and the closure it calls)
837 const char *signal_name; // or NULL, if not NULL we emit signal (or is set for signal)
838 LiVESClosure *closure; // or NULL, if not NULL we call closure
839 bool blocked;
840 } LiVESAccel;
841
842
843
844 typedef struct {
845 // values from 0.0 -> 1.0
846 double red;
847 double green;
848 double blue;
849 double alpha;
850 } LiVESWidgetColor;
851
852
return_true()853 boolean return_true() {
854 return TRUE;
855 }
856
857
858 typedef uint32_t LiVESEventMask;
859 #define LIVES_EXPOSURE_MASK (1<<0)
860 #define LIVES_POINTER_MOTION_MASK (1<<1)
861 #define LIVES_POINTER_MOTION_HINT_MASK (1<<2)
862 #define LIVES_BUTTON_MOTION_MASK (1<<3)
863 #define LIVES_BUTTON1_MOTION_MASK (1<<4)
864 #define LIVES_BUTTON2_MOTION_MASK (1<<5)
865 #define LIVES_BUTTON3_MOTION_MASK (1<<6)
866 #define LIVES_BUTTON_PRESS_MASK (1<<7)
867 #define LIVES_BUTTON_RELEASE_MASK (1<<8)
868 #define LIVES_KEY_PRESS_MASK (1<<9)
869 #define LIVES_KEY_RELEASE_MASK (1<<10)
870 #define LIVES_ENTER_NOTIFY_MASK (1<<11)
871 #define LIVES_LEAVE_NOTIFY_MASK (1<<12)
872 #define LIVES_FOCUS_CHANGE_MASK (1<<13)
873 #define LIVES_STRUCTURE_MASK (1<<14)
874 #define LIVES_PROPERTY_CHANGE_MASK (1<<15)
875 #define LIVES_VISIBILITY_NOTIFY_MASK (1<<16)
876 #define LIVES_PROXIMITY_IN_MASK (1<<17)
877 #define LIVES_PROXIMITY_OUT_MASK (1<<18)
878 #define LIVES_SUBSTRUCTURE_MASK (1<<19)
879 #define LIVES_SCROLL_MASK (1<<20)
880 #define LIVES_TOUCH_MASK (1<<21)
881 #define LIVES_SMOOTH_SCROLL_MASK (1<<22)
882
883 #define LIVES_ALL_EVENTS_MASK 0xFFFF
884
885 // events
886 #define LIVES_WIDGET_EXPOSE_EVENT "update"
887 #define LIVES_WIDGET_SCROLL_EVENT "scroll_event"
888 #define LIVES_WIDGET_ENTER_EVENT "enter-event"
889 #define LIVES_WIDGET_BUTTON_PRESS_EVENT "button-press-event"
890 #define LIVES_WIDGET_CONFIGURE_EVENT "resize"
891 #define LIVES_WIDGET_DELETE_EVENT "close-event"
892
893 // TODO - add: "motion_notify_event", "button_release_event", "leave-notify-event", "drag-data-received", "focus-out-event", "edited"
894
895
896 // signals
897 #define LIVES_WIDGET_CLICKED_EVENT "clicked"
898 #define LIVES_WIDGET_TOGGLED_EVENT "toggled"
899 #define LIVES_WIDGET_CHANGED_EVENT "changed"
900 #define LIVES_WIDGET_ACTIVATE_EVENT "activate"
901 #define LIVES_WIDGET_VALUE_CHANGED_EVENT "value-changed"
902 #define LIVES_WIDGET_SELECTION_CHANGED_EVENT "selection-changed"
903 #define LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT "current-folder-changed"
904 #define LIVES_WIDGET_RESPONSE_EVENT "response"
905
906 // add "unmap", "color-set", "drag-data-received", "mode-changed", "accept-position", "edited", "set-focus-child", "state-changed", "switch-page", "size-prepared"
907
908 extern "C" {
909 LiVESWidgetColor *lives_widget_color_copy(LiVESWidgetColor *c1orNULL, const LiVESWidgetColor *c2);
910 }
911
make_col(LiVESWidgetColor * col)912 static QString make_col(LiVESWidgetColor *col) {
913 QString qc = QString("rgba(%1,%2,%3,%4)")
914 .arg(col->red * 255.)
915 .arg(col->green * 255.)
916 .arg(col->blue * 255.)
917 .arg(col->alpha * 255.);
918 return qc;
919 }
920
921
922 typedef enum {
923 LIVES_OBJECT_TYPE_UNKNOWN,
924 LIVES_OBJECT_TYPE_TIMER,
925 LIVES_WIDGET_TYPE_BUTTON,
926 LIVES_WIDGET_TYPE_SPIN_BUTTON,
927 LIVES_WIDGET_TYPE_RADIO_BUTTON,
928 LIVES_WIDGET_TYPE_CHECK_BUTTON,
929 LIVES_WIDGET_TYPE_COLOR_BUTTON,
930 LIVES_WIDGET_TYPE_TOOL_BUTTON,
931 LIVES_WIDGET_TYPE_TOOLBAR,
932 LIVES_WIDGET_TYPE_BUTTON_BOX,
933 LIVES_WIDGET_TYPE_TEXT_VIEW,
934 LIVES_WIDGET_TYPE_SCALE,
935 LIVES_WIDGET_TYPE_SCROLLBAR,
936 LIVES_WIDGET_TYPE_SCROLLED_WINDOW,
937 LIVES_WIDGET_TYPE_PROGRESS_BAR,
938 LIVES_WIDGET_TYPE_PANED,
939 LIVES_WIDGET_TYPE_MENU,
940 LIVES_WIDGET_TYPE_MENU_ITEM,
941 LIVES_WIDGET_TYPE_TOOL_ITEM,
942 LIVES_WIDGET_TYPE_RADIO_MENU_ITEM,
943 LIVES_WIDGET_TYPE_CHECK_MENU_ITEM,
944 LIVES_WIDGET_TYPE_MENU_TOOL_BUTTON,
945 LIVES_WIDGET_TYPE_MENU_BAR,
946 LIVES_WIDGET_TYPE_ENTRY,
947 LIVES_WIDGET_TYPE_FRAME,
948 LIVES_WIDGET_TYPE_FILE_CHOOSER,
949 LIVES_WIDGET_TYPE_ARROW,
950 LIVES_WIDGET_TYPE_RULER,
951 LIVES_WIDGET_TYPE_COMBO,
952 LIVES_WIDGET_TYPE_TABLE,
953 LIVES_WIDGET_TYPE_DIALOG,
954 LIVES_WIDGET_TYPE_MESSAGE_DIALOG,
955 LIVES_WIDGET_TYPE_ALIGNMENT,
956 LIVES_WIDGET_TYPE_IMAGE,
957 LIVES_WIDGET_TYPE_LABEL,
958 LIVES_WIDGET_TYPE_NOTEBOOK,
959 LIVES_WIDGET_TYPE_TREE_VIEW,
960 LIVES_WIDGET_TYPE_HSEPARATOR,
961 LIVES_WIDGET_TYPE_VSEPARATOR,
962 LIVES_WIDGET_TYPE_MAIN_WINDOW,
963 LIVES_WIDGET_TYPE_SUB_WINDOW,
964 LIVES_WIDGET_TYPE_EVENT_BOX,
965 LIVES_WIDGET_TYPE_DRAWING_AREA,
966 LIVES_WIDGET_TYPE_HBOX,
967 LIVES_WIDGET_TYPE_VBOX,
968 } LiVESWidgetObjectType;
969
970
make_qkey_sequence(uint32_t key,LiVESXModifierType mods)971 LIVES_INLINE QKeySequence make_qkey_sequence(uint32_t key, LiVESXModifierType mods) {
972 return static_cast<Qt::Key>(key) | mods;
973 }
974
qkeysequence_get_key(QKeySequence ks)975 LIVES_INLINE uint32_t qkeysequence_get_key(QKeySequence ks) {
976 return ks[0] & 0x01FFFFFF;
977 }
978
979
qkeysequence_get_mod(QKeySequence ks)980 LIVES_INLINE LiVESXModifierType qkeysequence_get_mod(QKeySequence ks) {
981 return static_cast<LiVESXModifierType>(ks[0] & 0xF2000000);
982 }
983
984
985 class evFilter : public QObject {
986 public:
987
988 protected:
989 bool eventFilter(QObject *obj, QEvent *event);
990
991 };
992
993
994 #ifdef HAVE_X11
995
996 class nevfilter : public QAbstractNativeEventFilter {
997 public:
998
999 virtual bool nativeEventFilter(const QByteArray &eventType, livespointer message, long *);
1000
1001 };
1002
1003 #endif
1004
1005 class LiVESWidgetObject : public QWidget {
1006 Q_OBJECT
1007
1008 public:
1009
1010 void block_signal(ulong handler_id);
1011 void block_signals(const char *signame);
1012 void block_signals(ulong func, livespointer data);
1013 void unblock_signal(ulong handler_id);
1014 void unblock_signals(const char *signame);
1015 void unblock_signals(ulong func, livespointer data);
1016 void disconnect_signal(ulong handler_id);
1017
1018 void add_accel(LiVESAccel *accel);
1019 void add_accel(ulong handler_id, const char *signal_name, ulong funcptr, livespointer data);
1020 void add_accel(const char *signal_name, LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mod, LiVESAccelFlags flags);
1021
1022 boolean remove_accel(LiVESAccel *accel);
1023 boolean remove_accels(LiVESAccelGroup *, uint32_t key, LiVESXModifierType mod);
1024
1025 boolean remove_accel_group(LiVESAccelGroup *group);
1026 void add_accel_group(LiVESAccelGroup *group);
1027
1028 QList<LiVESAccelGroup *> get_accel_groups();
1029
1030 QList<LiVESAccel *> get_accels_for(LiVESAccelGroup *group, QKeySequence ks);
1031 QList<LiVESAccel *> get_accels_for(ulong func, livespointer data);
1032 QList<LiVESAccel *> get_accels_for(const char *signame);
1033 LiVESAccel *get_accel_for(ulong handler_id);
1034
1035 boolean activate_accel(uint32_t key, LiVESXModifierType mod);
1036 boolean activate_accel(QKeySequence ks);
1037
1038 void remove_all_accels();
1039
LiVESWidgetObject()1040 LiVESWidgetObject() {
1041 init();
1042 };
1043
1044
LiVESWidgetObject(const LiVESWidgetObject & xobj)1045 LiVESWidgetObject(const LiVESWidgetObject &xobj) {
1046 init();
1047 type = xobj.type;
1048 }
1049
ref_sink()1050 void ref_sink() {
1051 if (floating) floating = false;
1052 else inc_refcount();
1053 }
1054
inc_refcount()1055 void inc_refcount() {
1056 refcount++;
1057 }
1058
dec_refcount()1059 void dec_refcount() {
1060 if (--refcount == 0) {
1061 finalise();
1062 }
1063 }
1064
no_refcount()1065 void no_refcount() {
1066 refcount = 0;
1067 }
1068
1069
set_type(LiVESWidgetObjectType xtype)1070 void set_type(LiVESWidgetObjectType xtype) {
1071 type = xtype;
1072 }
1073
get_type()1074 LiVESWidgetObjectType get_type() {
1075 return type;
1076 }
1077
1078 private:
1079 bool floating;
1080 int refcount;
1081 evFilter *eFilter;
1082 QList<LiVESAccel *>accels;
1083 QList<LiVESAccelGroup *>accel_groups;
1084 LiVESWidgetObjectType type;
1085
init()1086 void init() {
1087 eFilter = new evFilter();
1088 (static_cast<QObject *>(this))->installEventFilter(eFilter);
1089 refcount = 1;
1090 type = LIVES_OBJECT_TYPE_UNKNOWN;
1091 }
1092
finalise(void)1093 void finalise(void) {
1094 (static_cast<QObject *>(this))->deleteLater(); // schedule for deletion
1095
1096 // remove us from all accel_groups
1097 while (accel_groups.size() > 0) {
1098 remove_accel_group(accel_groups[0]);
1099 }
1100
1101 remove_all_accels();
1102 }
1103
1104 };
1105
1106
1107 typedef struct LiVESList LiVESList;
1108
1109 struct LiVESList {
1110 livesconstpointer data;
1111 LiVESList *prev;
1112 LiVESList *next;
1113 };
1114
1115
1116 typedef struct LiVESSList LiVESSList;
1117
1118 struct LiVESSList {
1119 livesconstpointer data;
1120 LiVESSList *next;
1121 };
1122
1123 typedef LiVESList LiVESDList;
1124
1125
lives_list_nth_data(LiVESList * list,uint32_t n)1126 LIVES_INLINE livesconstpointer lives_list_nth_data(LiVESList *list, uint32_t n) {
1127 for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1128 if (list == NULL) return NULL;
1129 livesconstpointer data = list->data;
1130 return data;
1131 }
1132
lives_list_nth(LiVESList * list,uint32_t n)1133 LIVES_INLINE LiVESList *lives_list_nth(LiVESList *list, uint32_t n) {
1134 for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1135 return list;
1136 }
1137
lives_slist_nth_data(LiVESSList * list,uint32_t n)1138 LIVES_INLINE livesconstpointer lives_slist_nth_data(LiVESSList *list, uint32_t n) {
1139 for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1140 if (list == NULL) return NULL;
1141 livesconstpointer data = list->data;
1142 return data;
1143 }
1144
lives_list_length(LiVESList * list)1145 LIVES_INLINE int lives_list_length(LiVESList *list) {
1146 int i;
1147 for (i = 0; list != NULL; i++) list = list->next;
1148 return i;
1149 }
1150
lives_slist_length(LiVESSList * list)1151 LIVES_INLINE int lives_slist_length(LiVESSList *list) {
1152 int i;
1153 for (i = 0; list != NULL; i++) list = list->next;
1154 return i;
1155 }
1156
1157
1158
lives_list_remove(LiVESList * list,livesconstpointer data)1159 LIVES_INLINE LiVESList *lives_list_remove(LiVESList *list, livesconstpointer data) {
1160 LiVESList *olist = list;
1161 for (int i = 0; list->data != data && list != NULL; i++) list = list->next;
1162 if (list == NULL) return NULL;
1163 if (list->prev != NULL) list->prev->next = list->next;
1164 else olist = list->next;
1165 if (list->next != NULL) list->next->prev = list->prev;
1166
1167 list->next = list->prev = NULL;
1168
1169 return olist;
1170 }
1171
1172
lives_list_remove_link(LiVESList * olist,LiVESList * list)1173 LIVES_INLINE LiVESList *lives_list_remove_link(LiVESList *olist, LiVESList *list) {
1174 if (olist == NULL) return NULL;
1175
1176 if (list->prev != NULL) list->prev->next = list->next;
1177 else olist = list->next;
1178 if (list->next != NULL) list->next->prev = list->prev;
1179
1180 list->next = list->prev = NULL;
1181
1182 return olist;
1183 }
1184
1185
lives_slist_remove(LiVESSList * list,livesconstpointer data)1186 LIVES_INLINE LiVESSList *lives_slist_remove(LiVESSList *list, livesconstpointer data) {
1187 LiVESSList *olist = list, *xlist = list;
1188 for (int i = 0; list->data != data && list != NULL; i++) {
1189 xlist = list;
1190 list = list->next;
1191 }
1192 if (list == NULL) return NULL;
1193
1194 xlist->next = list->next;
1195
1196 if (list == olist) olist = list->next;
1197
1198 list->next = NULL;
1199
1200 return olist;
1201 }
1202
1203
lives_list_append(LiVESList * list,livesconstpointer data)1204 LIVES_INLINE LiVESList *lives_list_append(LiVESList *list, livesconstpointer data) {
1205 LiVESList *olist = NULL, *xlist = list;
1206
1207 while (list != NULL) {
1208 olist = list;
1209 list = list->next;
1210 }
1211
1212 LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1213 elem->data = data;
1214 elem->next = NULL;
1215 elem->prev = olist;
1216
1217 if (olist == NULL) xlist = elem;
1218 return xlist;
1219 }
1220
1221
lives_slist_append(LiVESSList * list,livesconstpointer data)1222 LIVES_INLINE LiVESSList *lives_slist_append(LiVESSList *list, livesconstpointer data) {
1223 LiVESSList *olist = NULL, *xlist = list;
1224
1225 while (list != NULL) {
1226 olist = list;
1227 list = list->next;
1228 }
1229
1230 LiVESSList *elem = (LiVESSList *)malloc(sizeof(LiVESSList));
1231 elem->data = data;
1232 elem->next = NULL;
1233
1234 if (olist == NULL) xlist = elem;
1235 return xlist;
1236 }
1237
1238
lives_list_prepend(LiVESList * list,livesconstpointer data)1239 LIVES_INLINE LiVESList *lives_list_prepend(LiVESList *list, livesconstpointer data) {
1240 LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1241 elem->data = data;
1242 elem->next = list;
1243 elem->prev = NULL;
1244 return elem;
1245 }
1246
1247
lives_slist_prepend(LiVESSList * list,livesconstpointer data)1248 LIVES_INLINE LiVESSList *lives_slist_prepend(LiVESSList *list, livesconstpointer data) {
1249 LiVESSList *elem = (LiVESSList *)malloc(sizeof(LiVESSList));
1250 elem->data = data;
1251 elem->next = list;
1252 return elem;
1253 }
1254
1255
lives_list_insert(LiVESList * list,livespointer data,int pos)1256 LIVES_INLINE LiVESList *lives_list_insert(LiVESList *list, livespointer data, int pos) {
1257 if (pos == 0) return lives_list_prepend(list, data);
1258
1259 LiVESList *xlist = list, *olist = NULL;
1260
1261 while (list != NULL && pos != 0) {
1262 olist = list;
1263 list = list->next;
1264 pos--;
1265 }
1266
1267 LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1268 elem->data = data;
1269 elem->next = olist->next;
1270 olist->next = elem;
1271 if (elem->next != NULL) elem->next->prev = elem;
1272 elem->prev = olist;
1273
1274 if (xlist == NULL) xlist = elem;
1275 return xlist;
1276
1277 }
1278
1279
1280
lives_list_find(LiVESList * list,livesconstpointer data)1281 LIVES_INLINE LiVESList *lives_list_find(LiVESList *list, livesconstpointer data) {
1282 while (list != NULL) {
1283 if (list->data == data) return list;
1284 list = list->next;
1285 }
1286 return NULL;
1287 }
1288
1289
lives_list_find_custom(LiVESList * list,livesconstpointer data,LiVESCompareFunc func)1290 LIVES_INLINE LiVESList *lives_list_find_custom(LiVESList *list, livesconstpointer data, LiVESCompareFunc func) {
1291 while (list != NULL) {
1292 if (! func(list->data, data))
1293 return list;
1294 list = list->next;
1295 }
1296 return NULL;
1297 }
1298
1299
1300
lives_list_free(LiVESList * list)1301 LIVES_INLINE void lives_list_free(LiVESList *list) {
1302 LiVESList *nlist;
1303 while (list != NULL) {
1304 nlist = list->next;
1305 free(list);
1306 list = nlist;
1307 }
1308 }
1309
1310
lives_slist_free(LiVESSList * list)1311 LIVES_INLINE void lives_slist_free(LiVESSList *list) {
1312 LiVESSList *nlist;
1313 while (list != NULL) {
1314 nlist = list->next;
1315 free(list);
1316 list = nlist;
1317 }
1318 }
1319
1320
lives_list_previous(LiVESList * list)1321 LIVES_INLINE LiVESList *lives_list_previous(LiVESList *list) {
1322 if (list == NULL) return NULL;
1323 return list->prev;
1324 }
1325
1326
lives_list_last(LiVESList * list)1327 LIVES_INLINE LiVESList *lives_list_last(LiVESList *list) {
1328 if (list == NULL) return NULL;
1329 while (list->next != NULL) list = list->next;
1330 return list;
1331 }
1332
1333
1334
lives_list_delete_link(LiVESList * list,LiVESList * link)1335 LIVES_INLINE LiVESList *lives_list_delete_link(LiVESList *list, LiVESList *link) {
1336 list = lives_list_remove_link(list, link);
1337 free(link);
1338 return list;
1339 }
1340
1341
lives_list_copy(LiVESList * list)1342 LIVES_INLINE LiVESList *lives_list_copy(LiVESList *list) {
1343 LiVESList *new_list = NULL;
1344 while (list != NULL) {
1345 lives_list_append(new_list, list->data);
1346 list = list->next;
1347 }
1348 return new_list;
1349 }
1350
1351
lives_list_concat(LiVESList * a,LiVESList * b)1352 LIVES_INLINE LiVESList *lives_list_concat(LiVESList *a, LiVESList *b) {
1353 LiVESList *xlist = lives_list_last(a);
1354 xlist->next = b;
1355 b->prev = xlist;
1356 return a;
1357 }
1358
1359
1360
lives_strsplit(const char * string,const char * delimiter,int max_tokens)1361 char **lives_strsplit(const char *string, const char *delimiter, int max_tokens) {
1362 LiVESSList *string_list = NULL, *slist;
1363 char **str_array;
1364 const char *s;
1365 uint32_t n = 0;
1366 const char *remainder;
1367 if (max_tokens < 1)
1368 max_tokens = INT_MAX;
1369 remainder = string;
1370 s = strstr(remainder, delimiter);
1371 if (s) {
1372 size_t delimiter_len = strlen(delimiter);
1373 while (--max_tokens && s) {
1374 size_t len;
1375 len = s - remainder;
1376 string_list = lives_slist_prepend(string_list, lives_strndup(remainder, len));
1377 n++;
1378 remainder = s + delimiter_len;
1379 s = strstr(remainder, delimiter);
1380 }
1381 }
1382 if (*string) {
1383 n++;
1384 string_list = lives_slist_prepend(string_list, lives_strdup(remainder));
1385 }
1386 str_array = (char **)lives_malloc((n + 1) * sizeof(char *));
1387 str_array[n--] = NULL;
1388 for (slist = string_list; slist; slist = slist->next)
1389 str_array[n--] = (char *)slist->data;
1390 lives_slist_free(string_list);
1391 return str_array;
1392 }
1393
1394
1395
lives_strdelimit(char * string,const char * delimiters,char new_delim)1396 char *lives_strdelimit(char *string, const char *delimiters, char new_delim) {
1397 char *c;
1398 for (c = string; *c; c++) {
1399 if (strchr(delimiters, *c))
1400 *c = new_delim;
1401 }
1402 return string;
1403 }
1404
1405
1406
1407
lives_strstr_len(const char * haystack,ssize_t haystack_len,const char * needle)1408 char *lives_strstr_len(const char *haystack, ssize_t haystack_len, const char *needle) {
1409 if (haystack_len < 0)
1410 return (char *)strstr(haystack, needle);
1411 else {
1412 const char *p = haystack;
1413 size_t needle_len = strlen(needle);
1414 const char *end;
1415 size_t i;
1416 if (needle_len == 0)
1417 return (char *)haystack;
1418 if (haystack_len < needle_len)
1419 return NULL;
1420 end = haystack + haystack_len - needle_len;
1421 while (p <= end && *p) {
1422 for (i = 0; i < needle_len; i++)
1423 if (p[i] != needle[i])
1424 goto next;
1425 return (char *)p;
1426 next:
1427 p++;
1428 }
1429 return NULL;
1430 }
1431 }
1432
1433
1434
1435 #define ICON_SCALE(a) ((int)(1.0 * a))
1436 typedef QSize LiVESIconSize;
1437 #define LIVES_ICON_SIZE_INVALID QSize(0,0)
1438 #define LIVES_ICON_SIZE_MENU QSize(ICON_SCALE(16),ICON_SCALE(16))
1439 #define LIVES_ICON_SIZE_SMALL_TOOLBAR QSize(ICON_SCALE(16),ICON_SCALE(16))
1440 #define LIVES_ICON_SIZE_LARGE_TOOLBAR QSize(ICON_SCALE(24),ICON_SCALE(24))
1441 #define LIVES_ICON_SIZE_BUTTON QSize(ICON_SCALE(16),ICON_SCALE(16))
1442 #define LIVES_ICON_SIZE_DND QSize(ICON_SCALE(32),ICON_SCALE(32))
1443 #define LIVES_ICON_SIZE_DIALOG QSize(ICON_SCALE(48),ICON_SCALE(48))
1444
1445
1446 typedef Qt::TransformationMode LiVESInterpType;
1447 #define LIVES_INTERP_BEST Qt::SmoothTransformation
1448 #define LIVES_INTERP_NORMAL Qt::SmoothTransformation
1449 #define LIVES_INTERP_FAST Qt::FastTransformation
1450
1451 typedef int LiVESResponseType;
1452 #define LIVES_RESPONSE_NONE QDialogButtonBox::InvalidRole
1453 #define LIVES_RESPONSE_OK QDialogButtonBox::AcceptRole
1454 #define LIVES_RESPONSE_CANCEL QDialogButtonBox::RejectRole
1455
1456 #define LIVES_RESPONSE_ACCEPT QDialogButtonBox::AcceptRole
1457
1458 #define LIVES_RESPONSE_YES QDialogButtonBox::YesRole
1459 #define LIVES_RESPONSE_NO QDialogButtonBox::NoRole
1460
1461 #define LIVES_RESPONSE_INVALID QDialogButtonBox::InvalidRole
1462 #define LIVES_RESPONSE_SHOW_DETAILS 100
1463
1464 #define LIVES_RESPONSE_RETRY 101
1465 #define LIVES_RESPONSE_ABORT 102
1466 #define LIVES_RESPONSE_RESET 103
1467
1468 typedef QStyle::StandardPixmap LiVESArrowType;
1469 #define LIVES_ARROW_UP QStyle::SP_ArrowUp
1470 #define LIVES_ARROW_DOWN QStyle::SP_ArrowDown
1471 #define LIVES_ARROW_LEFT QStyle::SP_ArrowLeft
1472 #define LIVES_ARROW_RIGHT QStyle::SP_ArrowRight
1473 #define LIVES_ARROW_NONE -1
1474
1475 class LiVESWidget : public LiVESWidgetObject {
1476 Q_OBJECT
1477
1478 public:
1479
Q_PROPERTY(bool prelight READ get_prelight WRITE set_prelight)1480 Q_PROPERTY(bool prelight READ get_prelight WRITE set_prelight)
1481
1482 void set_prelight(bool val) {
1483 (static_cast<QObject *>(static_cast<QWidget *>(this)))->setProperty("prelight", val);
1484 }
1485
get_prelight()1486 bool get_prelight() {
1487 QVariant qv = (static_cast<QObject *>(static_cast<QWidget *>(this)))->property("prelight");
1488 return qv.value<bool>();
1489 }
1490
1491 void set_fg_color(LiVESWidgetState state, const LiVESWidgetColor *col);
1492 void set_bg_color(LiVESWidgetState state, const LiVESWidgetColor *col);
1493 void set_base_color(LiVESWidgetState state, const LiVESWidgetColor *col);
1494 void set_text_color(LiVESWidgetState state, const LiVESWidgetColor *col);
1495
1496 LiVESWidgetColor *get_fg_color(LiVESWidgetState state);
1497 LiVESWidgetColor *get_bg_color(LiVESWidgetState state);
1498
1499 void update_stylesheet();
1500
1501
LiVESWidget()1502 LiVESWidget() : parent(NULL) {
1503
1504 QVariant qv = QVariant::fromValue(static_cast<LiVESWidgetObject *>(this));
1505 (static_cast<QWidget *>(this))->setProperty("LiVESWidgetObject", qv);
1506
1507 fg_norm = bg_norm = base_norm = text_norm = NULL;
1508 fg_act = bg_act = base_act = text_act = NULL;
1509 fg_insen = bg_insen = base_insen = text_insen = NULL;
1510 fg_hover = bg_hover = base_hover = text_hover = NULL;
1511 fg_sel = bg_sel = base_sel = text_sel = NULL;
1512 state = LIVES_WIDGET_STATE_NORMAL;
1513 widgetName = QString("%1").arg(ulong_random());
1514 events_mask = LIVES_EXPOSURE_MASK;
1515 onetime_events_mask = 0;
1516
1517 static_cast<QObject *>(static_cast<QWidget *>(this))->connect(static_cast<QObject *>(static_cast<QWidget *>(this)),
1518 SIGNAL(destroyed()),
1519 static_cast<QObject *>(static_cast<QWidget *>(this)),
1520 SLOT(onDestroyed()));
1521
1522 children = NULL;
1523 }
1524
onDestroyed()1525 void onDestroyed() {
1526 // if has child widgets, try to remove them and dec_refcount()
1527 // if widget is a toolitem/menuitem, remove its actions
1528
1529 // TODO - this should never get called, instead we should call dec_refcount()
1530
1531
1532 }
1533
1534 ~LiVESWidget();
1535
1536
add_child(LiVESWidget * child)1537 void add_child(LiVESWidget *child) {
1538 if (child->parent != NULL) return;
1539 child->set_parent(this);
1540 child->ref_sink();
1541 children = lives_list_append(children, child);
1542 }
1543
remove_child(LiVESWidget * child)1544 void remove_child(LiVESWidget *child) {
1545 children = lives_list_remove(children, child);
1546 child->set_parent(NULL);
1547 child->dec_refcount();
1548 }
1549
set_parent(LiVESWidget * new_parent)1550 void set_parent(LiVESWidget *new_parent) {
1551 parent = new_parent;
1552 }
1553
get_parent()1554 LiVESWidget *get_parent() {
1555 return parent;
1556 }
1557
get_name()1558 QString get_name() {
1559 return widgetName;
1560 }
1561
set_events(uint32_t mask)1562 void set_events(uint32_t mask) {
1563 events_mask = mask;
1564 }
1565
add_onetime_event_block(uint32_t mask)1566 void add_onetime_event_block(uint32_t mask) {
1567 onetime_events_mask |= mask;
1568 }
1569
remove_onetime_event_block(uint32_t mask)1570 void remove_onetime_event_block(uint32_t mask) {
1571 if (onetime_events_mask & mask) onetime_events_mask ^= mask;
1572 }
1573
get_onetime_events_block()1574 uint32_t get_onetime_events_block() {
1575 return onetime_events_mask;
1576 }
1577
get_events()1578 uint32_t get_events() {
1579 return events_mask;
1580 }
1581
count_children()1582 int count_children() {
1583 return lives_list_length(children);
1584 }
1585
get_children()1586 LiVESList *get_children() {
1587 return children;
1588 }
1589
set_children(LiVESList * xchildren)1590 void set_children(LiVESList *xchildren) {
1591 lives_list_free(children);
1592 children = xchildren;
1593 }
1594
get_child(int index)1595 LiVESWidget *get_child(int index) {
1596 return (LiVESWidget *)lives_list_nth_data(children, index);
1597 }
1598
1599
get_child_index(LiVESWidget * child)1600 int get_child_index(LiVESWidget *child) {
1601 LiVESList *xchildren = children;
1602 int i;
1603 for (i = 0; xchildren != NULL; i++) {
1604 if (xchildren->data == child) return i;
1605 }
1606 return -1;
1607 }
1608
get_state()1609 LiVESWidgetState get_state() {
1610 return state;
1611 }
1612
set_state(LiVESWidgetState xstate)1613 void set_state(LiVESWidgetState xstate) {
1614 state = xstate;
1615
1616 if (state & LIVES_WIDGET_STATE_INSENSITIVE) {
1617 setEnabled(false);
1618 } else {
1619 setEnabled(true);
1620 }
1621
1622
1623 if (state & LIVES_WIDGET_STATE_PRELIGHT) {
1624 if (!get_prelight()) set_prelight(true);
1625 } else {
1626 if (get_prelight()) set_prelight(false);
1627 }
1628
1629 }
1630
1631
1632 public slots:
cb_wrapper_clicked()1633 void cb_wrapper_clicked() {
1634 // "clicked" callback
1635 call_accels_for(LIVES_WIDGET_CLICKED_EVENT);
1636 }
1637
cb_wrapper_toggled()1638 void cb_wrapper_toggled() {
1639 // "toggled" callback
1640 call_accels_for(LIVES_WIDGET_CLICKED_EVENT);
1641 }
1642
1643
cb_wrapper_changed()1644 void cb_wrapper_changed() {
1645 // "changed" callback
1646 call_accels_for(LIVES_WIDGET_CHANGED_EVENT);
1647 }
1648
1649
cb_wrapper_value_changed()1650 void cb_wrapper_value_changed() {
1651 // "value-changed" callback
1652 call_accels_for(LIVES_WIDGET_VALUE_CHANGED_EVENT);
1653 }
1654
cb_wrapper_selection_changed()1655 void cb_wrapper_selection_changed() {
1656 // "selection-changed" callback
1657 call_accels_for(LIVES_WIDGET_SELECTION_CHANGED_EVENT);
1658 }
1659
cb_wrapper_current_folder_changed()1660 void cb_wrapper_current_folder_changed() {
1661 // "selection-changed" callback
1662 call_accels_for(LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT);
1663 }
1664
cb_wrapper_activate()1665 void cb_wrapper_activate() {
1666 // "activate" callback
1667 call_accels_for(LIVES_WIDGET_ACTIVATE_EVENT);
1668 }
1669
cb_wrapper_response()1670 void cb_wrapper_response() {
1671 // "response" callback
1672 call_accels_for(LIVES_WIDGET_RESPONSE_EVENT);
1673 }
1674
1675 private:
1676 LiVESList *children;
1677 LiVESWidget *parent;
1678 QString widgetName;
1679
1680 LiVESWidgetColor *fg_norm, *bg_norm, *base_norm, *text_norm;
1681 LiVESWidgetColor *fg_act, *bg_act, *base_act, *text_act;
1682 LiVESWidgetColor *fg_insen, *bg_insen, *base_insen, *text_insen;
1683 LiVESWidgetColor *fg_hover, *bg_hover, *base_hover, *text_hover;
1684 LiVESWidgetColor *fg_sel, *bg_sel, *base_sel, *text_sel;
1685
1686 LiVESWidgetState state;
1687
1688 uint32_t events_mask;
1689 uint32_t onetime_events_mask;
1690
call_accels_for(const char * type)1691 void call_accels_for(const char *type) {
1692 QList<LiVESAccel *> ql = get_accels_for(type);
1693 for (int i = 0; i < ql.size(); i++) {
1694 LiVESWidgetCallback *cb = (LiVESWidgetCallback *)ql[i]->closure->function;
1695 (*cb)(this, ql[i]->closure->data);
1696 }
1697 }
1698
1699 };
1700
1701
1702 #define LIVES_IS_WIDGET_OBJECT(a) 1
1703 #define LIVES_IS_WIDGET(a) 1
1704 #define LIVES_IS_CONTAINER(a) 1
1705 #define LIVES_IS_XWINDOW(a) 1
1706
1707 #define LIVES_IS_BUTTON(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_BUTTON || \
1708 static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_CHECK_BUTTON)
1709 #define LIVES_IS_PUSH_BUTTON(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_BUTTON || \
1710 static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_RADIO_BUTTON)
1711 #define LIVES_IS_RANGE(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SCALE || \
1712 static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SCROLLBAR)
1713 #define LIVES_IS_LABEL(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_LABEL)
1714 #define LIVES_IS_TOGGLE_BUTTON(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_CHECK_BUTTON)
1715 #define LIVES_IS_HBOX(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_HBOX)
1716 #define LIVES_IS_VBOX(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_VBOX)
1717 #define LIVES_IS_COMBO(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_COMBO)
1718 #define LIVES_IS_ENTRY(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_ENTRY)
1719 #define LIVES_IS_MENU(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_MENU)
1720 #define LIVES_IS_MENU_BAR(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_MENU_BAR)
1721 #define LIVES_IS_MENU_ITEM(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_MENU_ITEM)
1722 #define LIVES_IS_TOOLBAR(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TOOLBAR)
1723 #define LIVES_IS_FILE_CHOOSER(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_FILE_CHOOSER)
1724 #define LIVES_IS_SCALE(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SCALE)
1725 #define LIVES_IS_FRAME(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_FRAME)
1726 #define LIVES_IS_TOOL_ITEM(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TOOL_ITEM)
1727 #define LIVES_IS_WINDOW(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_MAIN_WINDOW)
1728 #define LIVES_IS_DIALOG(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SUB_WINDOW || \
1729 static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_MESSAGE_DIALOG)
1730 #define LIVES_IS_PANED(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_PANED)
1731 #define LIVES_IS_TABLE(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TABLE)
1732 #define LIVES_IS_IMAGE(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_IMAGE)
1733 #define LIVES_IS_PIXBUF(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_IMAGE)
1734 #define LIVES_IS_NOTEBOOK(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_NOTEBOOK)
1735 #define LIVES_IS_SPIN_BUTTON(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SPIN_BUTTON)
1736 #define LIVES_IS_SCROLLBAR(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SCROLLBAR)
1737 #define LIVES_IS_TREE_VIEW(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TREE_VIEW)
1738 #define LIVES_IS_TEXT_VIEW(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TEXT_VIEW)
1739 #define LIVES_IS_TEXT_BUFFER(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_TEXT_BUFFER)
1740 #define LIVES_IS_SCROLLED_WINDOW(a) (static_cast<LiVESWidgetObject *>(a)->get_type() == LIVES_WIDGET_TYPE_SCROLLED_WINDOW)
1741
1742
eventFilter(QObject * obj,QEvent * event)1743 bool evFilter::eventFilter(QObject *obj, QEvent *event) {
1744
1745 // TODO - add motion-notify-event, leave-notify-event, button-release-event, focus_out_event
1746
1747 // event->accept() to block ?
1748
1749 // return true to block ?
1750
1751 switch (event->type()) {
1752
1753 case (QEvent::Shortcut): {
1754 QShortcutEvent *qevent = static_cast<QShortcutEvent *>(event);
1755 QKeySequence ks = qevent->key();
1756 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1757 object->activate_accel(ks);
1758 return false;
1759 }
1760
1761 case (QEvent::Wheel): {
1762 QWheelEvent *qevent = static_cast<QWheelEvent *>(event);
1763 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1764 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1765 if (!(widget->get_events() & LIVES_SCROLL_MASK)) return true;
1766 if (!(widget->get_onetime_events_block() & LIVES_SCROLL_MASK)) {
1767 widget->remove_onetime_event_block(LIVES_SCROLL_MASK);
1768 event->accept();
1769 return true;
1770 }
1771 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_SCROLL_EVENT);
1772 LiVESXEventScroll *scrollevent = NULL;
1773 if (qevent->angleDelta().y() > 0) scrollevent->direction = LIVES_SCROLL_UP;
1774 else scrollevent->direction = LIVES_SCROLL_DOWN;
1775
1776 scrollevent->state = QApplication::queryKeyboardModifiers();
1777
1778 for (int i = 0; i < accels.size(); i++) {
1779 LiVESScrollEventCallback *cb = (LiVESScrollEventCallback *)accels[i]->closure->function;
1780 bool ret = (*cb)(widget, scrollevent, accels[i]->closure->data);
1781 if (ret) return true;
1782 }
1783 }
1784
1785 case (QEvent::Paint): {
1786 QPaintEvent *qevent = static_cast<QPaintEvent *>(event);
1787 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1788 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1789 if (!(widget->get_events() & LIVES_EXPOSURE_MASK)) return true;
1790 if (!(widget->get_onetime_events_block() & LIVES_EXPOSURE_MASK)) {
1791 widget->remove_onetime_event_block(LIVES_EXPOSURE_MASK);
1792 event->accept();
1793 return true;
1794 }
1795 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_EXPOSE_EVENT);
1796 LiVESXEventExpose *exposeevent = NULL;
1797 QRect qr = qevent->rect();
1798 exposeevent->area.x = qr.x();
1799 exposeevent->area.y = qr.y();
1800 exposeevent->area.width = qr.width();
1801 exposeevent->area.height = qr.height();
1802
1803 exposeevent->count = 0;
1804
1805 for (int i = 0; i < accels.size(); i++) {
1806 LiVESExposeEventCallback *cb = (LiVESExposeEventCallback *)accels[i]->closure->function;
1807 bool ret = (*cb)(widget, exposeevent, accels[i]->closure->data);
1808 if (ret) return true;
1809 }
1810 }
1811
1812 case (QEvent::Enter): {
1813 //QEnterEvent *qevent = static_cast<QEnterEvent *>(event);
1814 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1815 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1816 if (!(widget->get_events() & LIVES_ENTER_NOTIFY_MASK)) return true;
1817 if (!(widget->get_onetime_events_block() & LIVES_ENTER_NOTIFY_MASK)) {
1818 widget->remove_onetime_event_block(LIVES_ENTER_NOTIFY_MASK);
1819 event->accept();
1820 return true;
1821 }
1822 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_ENTER_EVENT);
1823 LiVESXEventCrossing *crossingevent = NULL;
1824
1825 for (int i = 0; i < accels.size(); i++) {
1826 LiVESEnterEventCallback *cb = (LiVESEnterEventCallback *)accels[i]->closure->function;
1827 bool ret = (*cb)(widget, crossingevent, accels[i]->closure->data);
1828 if (ret) return true;
1829 }
1830 }
1831
1832 case (QEvent::MouseButtonPress): {
1833 QMouseEvent *qevent = static_cast<QMouseEvent *>(event);
1834 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1835 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1836 if (!(widget->get_events() & LIVES_BUTTON_PRESS_MASK)) return true;
1837 if (!(widget->get_onetime_events_block() & LIVES_BUTTON_PRESS_MASK)) {
1838 widget->remove_onetime_event_block(LIVES_BUTTON_PRESS_MASK);
1839 event->accept();
1840 return true;
1841 }
1842 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_BUTTON_PRESS_EVENT);
1843
1844 LiVESXEventButton *buttonevent = NULL;
1845 if (qevent->button() == Qt::LeftButton) buttonevent->button = 1;
1846 if (qevent->button() == Qt::MidButton) buttonevent->button = 2;
1847 if (qevent->button() == Qt::RightButton) buttonevent->button = 3;
1848
1849 buttonevent->type = LIVES_BUTTON_PRESS;
1850 buttonevent->time = qtime->elapsed();
1851
1852 for (int i = 0; i < accels.size(); i++) {
1853 LiVESButtonEventCallback *cb = (LiVESButtonEventCallback *)accels[i]->closure->function;
1854 bool ret = (*cb)(widget, buttonevent, accels[i]->closure->data);
1855 if (ret) return true;
1856 }
1857 }
1858
1859 case (QEvent::MouseButtonDblClick): {
1860 QMouseEvent *qevent = static_cast<QMouseEvent *>(event);
1861 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1862 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1863 if (!(widget->get_events() & LIVES_BUTTON_PRESS_MASK)) return true;
1864 if (!(widget->get_onetime_events_block() & LIVES_BUTTON_PRESS_MASK)) {
1865 widget->remove_onetime_event_block(LIVES_BUTTON_PRESS_MASK);
1866 event->accept();
1867 return true;
1868 }
1869 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_BUTTON_PRESS_EVENT);
1870
1871 LiVESXEventButton *buttonevent = NULL;
1872 if (qevent->button() == Qt::LeftButton) buttonevent->button = 1;
1873 if (qevent->button() == Qt::MidButton) buttonevent->button = 2;
1874 if (qevent->button() == Qt::RightButton) buttonevent->button = 3;
1875
1876 buttonevent->type = LIVES_BUTTON2_PRESS;
1877
1878 for (int i = 0; i < accels.size(); i++) {
1879 LiVESButtonEventCallback *cb = (LiVESButtonEventCallback *)accels[i]->closure->function;
1880 bool ret = (*cb)(widget, buttonevent, accels[i]->closure->data);
1881 if (ret) return true;
1882 }
1883 }
1884
1885 case (QEvent::Resize): {
1886 //QShowEvent *qevent = static_cast<QResizeEvent *>(event);
1887 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1888 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1889 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_CONFIGURE_EVENT);
1890 LiVESXEventConfigure *configureevent = NULL;
1891
1892 for (int i = 0; i < accels.size(); i++) {
1893 LiVESConfigureEventCallback *cb = (LiVESConfigureEventCallback *)accels[i]->closure->function;
1894 bool ret = (*cb)(widget, configureevent, accels[i]->closure->data);
1895 if (ret) return true;
1896 }
1897 }
1898
1899 case (QEvent::Close): {
1900 //QCloseEvent *qevent = static_cast<QCloseEvent *>(event);
1901 LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1902 LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1903 QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_DELETE_EVENT);
1904 LiVESXEventDelete *deleteevent = NULL;
1905
1906 for (int i = 0; i < accels.size(); i++) {
1907 LiVESDeleteEventCallback *cb = (LiVESDeleteEventCallback *)accels[i]->closure->function;
1908 bool ret = (*cb)(widget, deleteevent, accels[i]->closure->data);
1909 if (ret) return true;
1910 }
1911 }
1912
1913 default:
1914 return false;
1915
1916 }
1917
1918 return false; // continue
1919 }
1920
1921
1922
1923
update_stylesheet()1924 void LiVESWidget::update_stylesheet() {
1925 QWidget *qw = static_cast<QWidget *>(this);
1926 QString stylesheet;
1927 QString col;
1928
1929 stylesheet = "QWidget#" + widgetName + " {color: ";
1930 col = make_col(fg_norm);
1931 stylesheet += col;
1932 stylesheet += "; background-color: ";
1933 col = make_col(bg_norm);
1934 stylesheet += col;
1935 stylesheet += "; selection-background-color: ";
1936 col = make_col(bg_sel);
1937 stylesheet += col;
1938 stylesheet += "; selection-color: ";
1939 col = make_col(fg_sel);
1940 stylesheet += col;
1941 stylesheet += " } ";
1942 stylesheet = "QWidget#" + widgetName + ":active {color: ";
1943 col = make_col(fg_act);
1944 stylesheet += col;
1945 stylesheet += "; background-color: ";
1946 col = make_col(bg_act);
1947 stylesheet += col;
1948 stylesheet += " } ";
1949 stylesheet = "QWidget#" + widgetName + ":[prelight=true] {color: ";
1950 col = make_col(fg_hover);
1951 stylesheet += col;
1952 stylesheet += "; background-color: ";
1953 col = make_col(bg_hover);
1954 stylesheet += col;
1955 stylesheet += " } ";
1956 stylesheet = "QWidget#" + widgetName + ":hover {color: ";
1957 col = make_col(fg_hover);
1958 stylesheet += col;
1959 stylesheet += "; background-color: ";
1960 col = make_col(bg_hover);
1961 stylesheet += col;
1962 stylesheet += " } ";
1963 stylesheet = "QWidget#" + widgetName + ":disabled {color: ";
1964 col = make_col(fg_insen);
1965 stylesheet += col;
1966 stylesheet += "; background-color: ";
1967 col = make_col(bg_insen);
1968 stylesheet += col;
1969 stylesheet += " } ";
1970
1971 qw->setStyleSheet(stylesheet);
1972 qw->update();
1973 }
1974
1975
1976
set_fg_color(LiVESWidgetState state,const LiVESWidgetColor * col)1977 void LiVESWidget::set_fg_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
1978 switch (state) {
1979 case (LIVES_WIDGET_STATE_NORMAL):
1980 lives_widget_color_copy(fg_norm, col);
1981 break;
1982 case (LIVES_WIDGET_STATE_ACTIVE):
1983 lives_widget_color_copy(fg_act, col);
1984 break;
1985 case (LIVES_WIDGET_STATE_INSENSITIVE):
1986 lives_widget_color_copy(fg_insen, col);
1987 break;
1988 case (LIVES_WIDGET_STATE_PRELIGHT):
1989 lives_widget_color_copy(fg_hover, col);
1990 break;
1991 case (LIVES_WIDGET_STATE_SELECTED):
1992 lives_widget_color_copy(fg_sel, col);
1993 break;
1994 default:
1995 break;
1996 }
1997 update_stylesheet();
1998 }
1999
2000
set_bg_color(LiVESWidgetState state,const LiVESWidgetColor * col)2001 void LiVESWidget::set_bg_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2002 switch (state) {
2003 case (LIVES_WIDGET_STATE_NORMAL):
2004 lives_widget_color_copy(bg_norm, col);
2005 break;
2006 case (LIVES_WIDGET_STATE_ACTIVE):
2007 lives_widget_color_copy(bg_act, col);
2008 break;
2009 case (LIVES_WIDGET_STATE_INSENSITIVE):
2010 lives_widget_color_copy(bg_insen, col);
2011 break;
2012 case (LIVES_WIDGET_STATE_PRELIGHT):
2013 lives_widget_color_copy(bg_hover, col);
2014 break;
2015 case (LIVES_WIDGET_STATE_SELECTED):
2016 lives_widget_color_copy(bg_sel, col);
2017 break;
2018 default:
2019 break;
2020 }
2021 update_stylesheet();
2022 }
2023
2024
set_base_color(LiVESWidgetState state,const LiVESWidgetColor * col)2025 void LiVESWidget::set_base_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2026 switch (state) {
2027 case (LIVES_WIDGET_STATE_NORMAL):
2028 lives_widget_color_copy(base_norm, col);
2029 break;
2030 case (LIVES_WIDGET_STATE_ACTIVE):
2031 lives_widget_color_copy(base_act, col);
2032 break;
2033 case (LIVES_WIDGET_STATE_INSENSITIVE):
2034 lives_widget_color_copy(base_insen, col);
2035 break;
2036 case (LIVES_WIDGET_STATE_PRELIGHT):
2037 lives_widget_color_copy(base_hover, col);
2038 break;
2039 case (LIVES_WIDGET_STATE_SELECTED):
2040 lives_widget_color_copy(base_sel, col);
2041 break;
2042 default:
2043 break;
2044 }
2045 update_stylesheet();
2046 }
2047
2048
set_text_color(LiVESWidgetState state,const LiVESWidgetColor * col)2049 void LiVESWidget::set_text_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2050 switch (state) {
2051 case (LIVES_WIDGET_STATE_NORMAL):
2052 lives_widget_color_copy(text_norm, col);
2053 break;
2054 case (LIVES_WIDGET_STATE_ACTIVE):
2055 lives_widget_color_copy(text_act, col);
2056 break;
2057 case (LIVES_WIDGET_STATE_INSENSITIVE):
2058 lives_widget_color_copy(text_insen, col);
2059 break;
2060 case (LIVES_WIDGET_STATE_PRELIGHT):
2061 lives_widget_color_copy(text_hover, col);
2062 break;
2063 case (LIVES_WIDGET_STATE_SELECTED):
2064 lives_widget_color_copy(text_sel, col);
2065 break;
2066 default:
2067 break;
2068 }
2069 update_stylesheet();
2070 }
2071
2072
get_fg_color(LiVESWidgetState state)2073 LiVESWidgetColor *LiVESWidget::get_fg_color(LiVESWidgetState state) {
2074 switch (state) {
2075 case (LIVES_WIDGET_STATE_NORMAL):
2076 return fg_norm;
2077 break;
2078 case (LIVES_WIDGET_STATE_ACTIVE):
2079 return fg_act;
2080 break;
2081 case (LIVES_WIDGET_STATE_INSENSITIVE):
2082 return fg_insen;
2083 break;
2084 case (LIVES_WIDGET_STATE_PRELIGHT):
2085 return fg_hover;
2086 break;
2087 case (LIVES_WIDGET_STATE_SELECTED):
2088 return fg_sel;
2089 break;
2090 default:
2091 break;
2092 }
2093 return NULL;
2094 }
2095
2096
get_bg_color(LiVESWidgetState state)2097 LiVESWidgetColor *LiVESWidget::get_bg_color(LiVESWidgetState state) {
2098 switch (state) {
2099 case (LIVES_WIDGET_STATE_NORMAL):
2100 return bg_norm;
2101 break;
2102 case (LIVES_WIDGET_STATE_ACTIVE):
2103 return bg_act;
2104 break;
2105 case (LIVES_WIDGET_STATE_INSENSITIVE):
2106 return bg_insen;
2107 break;
2108 case (LIVES_WIDGET_STATE_PRELIGHT):
2109 return bg_hover;
2110 break;
2111 case (LIVES_WIDGET_STATE_SELECTED):
2112 return bg_sel;
2113 break;
2114 default:
2115 break;
2116 }
2117 return NULL;
2118 }
2119
2120
lives_signal_connect(LiVESWidgetObject * object,const char * signal_name,ulong funcptr,livespointer data)2121 ulong lives_signal_connect(LiVESWidgetObject *object, const char *signal_name, ulong funcptr, livespointer data) {
2122 ulong handler_id;
2123 handler_id = ulong_random();
2124
2125 object->add_accel(handler_id, signal_name, funcptr, data);
2126
2127 if (!strcmp(signal_name, LIVES_WIDGET_CLICKED_EVENT)) {
2128 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2129 SIGNAL(clicked()),
2130 static_cast<QObject *>(object),
2131 SLOT(cb_wrapper_clicked()));
2132 } else if (!strcmp(signal_name, LIVES_WIDGET_TOGGLED_EVENT)) {
2133 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2134 SIGNAL(toggled()),
2135 static_cast<QObject *>(object),
2136 SLOT(cb_wrapper_toggled()));
2137 } else if (!strcmp(signal_name, LIVES_WIDGET_CHANGED_EVENT)) {
2138 // for combo, entry, LiVESTreeSelection
2139 if (LIVES_IS_COMBO(object))
2140 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2141 SIGNAL(currentTextChanged()),
2142 static_cast<QObject *>(object),
2143 SLOT(cb_wrapper_changed()));
2144
2145 else if (LIVES_IS_ENTRY(object))
2146 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2147 SIGNAL(textChanged()),
2148 static_cast<QObject *>(object),
2149 SLOT(cb_wrapper_changed()));
2150
2151 else {
2152 QTreeWidget *qtw = dynamic_cast<QTreeWidget *>(object);
2153 if (qtw != NULL) {
2154 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2155 SIGNAL(itemSelectionChanged()),
2156 static_cast<QObject *>(object),
2157 SLOT(cb_wrapper_changed()));
2158
2159 }
2160 }
2161 } else if (!strcmp(signal_name, LIVES_WIDGET_VALUE_CHANGED_EVENT)) {
2162 // for spinbutton, scrollbar
2163 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2164 SIGNAL(valueChanged()),
2165 static_cast<QObject *>(object),
2166 SLOT(cb_wrapper_value_changed()));
2167
2168 } else if (!strcmp(signal_name, LIVES_WIDGET_SELECTION_CHANGED_EVENT)) {
2169 // for filedialog
2170 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2171 SIGNAL(currentChanged()),
2172 static_cast<QObject *>(object),
2173 SLOT(cb_wrapper_selection_changed()));
2174
2175 } else if (!strcmp(signal_name, LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT)) {
2176 // for filedialog
2177 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2178 SIGNAL(currentUrlChanged()),
2179 static_cast<QObject *>(object),
2180 SLOT(cb_wrapper_current_folder_changed()));
2181
2182 } else if (!strcmp(signal_name, LIVES_WIDGET_ACTIVATE_EVENT)) {
2183 // for menuitems (QAction)
2184 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2185 SIGNAL(triggered()),
2186 static_cast<QObject *>(object),
2187 SLOT(cb_wrapper_activate()));
2188
2189 } else if (!strcmp(signal_name, LIVES_WIDGET_RESPONSE_EVENT)) {
2190 // for menuitems (QAction)
2191 (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2192 SIGNAL(finished()),
2193 static_cast<QObject *>(object),
2194 SLOT(cb_wrapper_response()));
2195
2196 }
2197
2198
2199 return handler_id;
2200 }
2201
2202
lives_widget_object_set_data(LiVESWidgetObject * widget,const char * prop,livespointer value)2203 LIVES_INLINE void lives_widget_object_set_data(LiVESWidgetObject *widget, const char *prop, livespointer value) {
2204 QVariant v = qVariantFromValue((livespointer) value);
2205 widget->setProperty(prop, v);
2206 }
2207
2208
lives_widget_object_get_data(LiVESWidgetObject * widget,const char * prop)2209 LIVES_INLINE livespointer lives_widget_object_get_data(LiVESWidgetObject *widget, const char *prop) {
2210 QVariant v = widget->property(prop);
2211 return v.value<livespointer>();
2212 }
2213
2214
2215
2216
2217 #define lives_signal_connect_after(a,b,c,d) lives_signal_connect(a,b,c,d)
2218
2219
2220
add_accel(LiVESAccel * accel)2221 void LiVESWidgetObject::add_accel(LiVESAccel *accel) {
2222 accels.push_back(accel);
2223
2224 //QShortcut *shortcut = new QShortcut(accel->ks, dynamic_cast<QWidget *>(this));
2225 //accel->shortcut = shortcut;
2226 }
2227
2228
add_accel(ulong handler_id,const char * signal_name,ulong funcptr,livespointer data)2229 void LiVESWidgetObject::add_accel(ulong handler_id, const char *signal_name, ulong funcptr, livespointer data) {
2230 LiVESAccel *accel = new LiVESAccel;
2231 accel->handler_id = handler_id;
2232 accel->signal_name = strdup(signal_name);
2233 LiVESClosure *cl = new LiVESClosure;
2234 cl->function = funcptr;
2235 cl->data = data;
2236 accel->closure = cl;
2237 add_accel(accel);
2238 }
2239
2240
add_accel(const char * signal_name,LiVESAccelGroup * group,uint32_t key,LiVESXModifierType mod,LiVESAccelFlags flags)2241 void LiVESWidgetObject::add_accel(const char *signal_name, LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mod,
2242 LiVESAccelFlags flags) {
2243 LiVESAccel *accel = new LiVESAccel;
2244 accel->handler_id = 0;
2245 accel->signal_name = strdup(signal_name);
2246 accel->closure = NULL;
2247 accel->group = group;
2248 accel->ks = make_qkey_sequence(key, mod);
2249 accel->flags = flags;
2250 add_accel(accel);
2251 }
2252
2253
remove_accel(LiVESAccel * accel)2254 boolean LiVESWidgetObject::remove_accel(LiVESAccel *accel) {
2255 QList<LiVESAccel *>::iterator it = accels.begin();
2256
2257 while (it != accels.end()) {
2258 if (((LiVESAccel *)*it) == accel) {
2259 delete accel->shortcut;
2260 delete accel->signal_name;
2261 delete accel->closure;
2262 accels.erase(it);
2263 return TRUE;
2264 } else
2265 ++it;
2266 }
2267
2268 return FALSE;
2269 }
2270
2271
activate_accel(uint32_t key,LiVESXModifierType mod)2272 boolean LiVESWidgetObject::activate_accel(uint32_t key, LiVESXModifierType mod) {
2273 return activate_accel(make_qkey_sequence(key, mod));
2274 }
2275
2276
activate_accel(QKeySequence ks)2277 boolean LiVESWidgetObject::activate_accel(QKeySequence ks) {
2278 for (int j = 0; j < accel_groups.size(); j++) {
2279 QList<LiVESAccel *> ql = get_accels_for(accel_groups.at(j), ks);
2280 for (int i = 0; i < ql.size(); i++) {
2281 LiVESAccel *accel = ql.at(i);
2282 if (accel->closure != NULL) {
2283 LiVESAccelCallback *cb = (LiVESAccelCallback *)accel->closure->function;
2284 uint32_t key = qkeysequence_get_key(ks);
2285 LiVESXModifierType mod = qkeysequence_get_mod(ks);
2286 (*cb)(accel->group, this, key, mod, accel->closure->data);
2287 } else {
2288 if (!strcmp(accel->signal_name, LIVES_WIDGET_CLICKED_EVENT)) {
2289 QAbstractButton *widget = dynamic_cast<QAbstractButton *>(this);
2290 if (widget != NULL) widget->click();
2291 }
2292
2293 if (!strcmp(accel->signal_name, LIVES_WIDGET_TOGGLED_EVENT)) {
2294 QAbstractButton *widget = dynamic_cast<QAbstractButton *>(this);
2295 if (widget != NULL) widget->toggle();
2296 }
2297
2298 }
2299 return TRUE;
2300 }
2301 }
2302 return FALSE;
2303 }
2304
2305
2306
remove_all_accels()2307 void LiVESWidgetObject::remove_all_accels() {
2308 QList<LiVESAccel *>::iterator it = accels.begin();
2309 while (it != accels.end()) {
2310 remove_accel((LiVESAccel *)*it);
2311 }
2312 }
2313
2314
get_accels_for(ulong func,livespointer data)2315 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(ulong func, livespointer data) {
2316 QList<LiVESAccel *> ql;
2317 for (int i = 0; i < accels.size(); i++) {
2318 if (accels[i]->closure == NULL) continue;
2319 if (accels[i]->closure->function == func && accels[i]->closure->data == data) ql.push_back(accels[i]);
2320 }
2321 return ql;
2322 }
2323
2324
get_accels_for(const char * signame)2325 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(const char *signame) {
2326 QList<LiVESAccel *> ql;
2327 for (int i = 0; i < accels.size(); i++) {
2328 if (accels[i]->signal_name == signame) ql.push_back(accels[i]);
2329 }
2330 return ql;
2331 }
2332
2333
get_accel_for(ulong handler_id)2334 LiVESAccel *LiVESWidgetObject::get_accel_for(ulong handler_id) {
2335 for (int i = 0; i < accels.size(); i++) {
2336 if (accels[i]->handler_id == handler_id) {
2337 return accels[i];
2338 }
2339 }
2340 return NULL;
2341 }
2342
2343
block_signal(ulong handler_id)2344 void LiVESWidgetObject::block_signal(ulong handler_id) {
2345 LiVESAccel *accel = get_accel_for(handler_id);
2346 accel->blocked = true;
2347 }
2348
2349
block_signals(const char * signame)2350 void LiVESWidgetObject::block_signals(const char *signame) {
2351 QList<LiVESAccel *>ql = get_accels_for(signame);
2352 for (int i = 0; i < ql.size(); i++) {
2353 ql[i]->blocked = true;
2354 }
2355 }
2356
block_signals(ulong func,livespointer data)2357 void LiVESWidgetObject::block_signals(ulong func, livespointer data) {
2358 QList<LiVESAccel *>ql = get_accels_for(func, data);
2359 for (int i = 0; i < ql.size(); i++) {
2360 ql[i]->blocked = true;
2361 }
2362 }
2363
2364
unblock_signal(ulong handler_id)2365 void LiVESWidgetObject::unblock_signal(ulong handler_id) {
2366 LiVESAccel *accel = get_accel_for(handler_id);
2367 accel->blocked = false;
2368 }
2369
2370
unblock_signals(const char * signame)2371 void LiVESWidgetObject::unblock_signals(const char *signame) {
2372 QList<LiVESAccel *>ql = get_accels_for(signame);
2373 for (int i = 0; i < ql.size(); i++) {
2374 ql[i]->blocked = false;
2375 }
2376 }
2377
2378
unblock_signals(ulong func,livespointer data)2379 void LiVESWidgetObject::unblock_signals(ulong func, livespointer data) {
2380 QList<LiVESAccel *>ql = get_accels_for(func, data);
2381 for (int i = 0; i < ql.size(); i++) {
2382 ql[i]->blocked = false;
2383 }
2384 }
2385
2386
disconnect_signal(ulong handler_id)2387 void LiVESWidgetObject::disconnect_signal(ulong handler_id) {
2388 LiVESAccel *accel = get_accel_for(handler_id);
2389 remove_accel(accel);
2390 }
2391
2392
get_accel_groups()2393 QList<LiVESAccelGroup *> LiVESWidgetObject::get_accel_groups() {
2394 return accel_groups;
2395 }
2396
2397
2398
2399 class LiVESBox : public LiVESWidget {};
2400
2401
2402 class LiVESHBox : public LiVESBox, public QHBoxLayout {
2403 public:
LiVESHBox()2404 LiVESHBox() {
2405 set_type(LIVES_WIDGET_TYPE_HBOX);
2406 }
2407 };
2408
2409
2410 class LiVESEventBox : public LiVESBox, public QHBoxLayout {
2411 public:
LiVESEventBox()2412 LiVESEventBox() {
2413 set_type(LIVES_WIDGET_TYPE_EVENT_BOX);
2414 }
2415 };
2416
2417
2418 class LiVESDrawingArea : public LiVESBox, public QHBoxLayout {
2419 public:
LiVESDrawingArea()2420 LiVESDrawingArea() {
2421 set_type(LIVES_WIDGET_TYPE_DRAWING_AREA);
2422 }
2423 };
2424
2425
2426 class LiVESVBox : public LiVESBox, public QVBoxLayout {
2427 public:
LiVESVBox()2428 LiVESVBox() {
2429 set_type(LIVES_WIDGET_TYPE_VBOX);
2430 }
2431 };
2432
2433
2434 typedef class LiVESRange LiVESRange;
2435
2436 class LiVESAdjustment : public LiVESWidgetObject {
2437
2438 public:
2439
LiVESAdjustment(double xval,double low,double upp,double step_i,double page_i,double page_s)2440 LiVESAdjustment(double xval, double low, double upp, double step_i, double page_i, double page_s) :
2441 value(xval), lower(low), upper(upp), step_increment(step_i), page_increment(page_i), page_size(page_s), frozen(FALSE) {};
2442
2443 void set_value(double newval);
2444 void set_lower(double newval);
2445
2446 void set_upper(double newval);
2447 void set_step_increment(double newval);
2448 void set_page_increment(double newval);
2449 void set_page_size(double newval);
2450
set_owner(LiVESWidget * widget)2451 void set_owner(LiVESWidget *widget) {
2452 owner = widget;
2453 }
2454
get_owner()2455 LiVESWidget *get_owner() {
2456 return owner;
2457 }
2458
2459
get_value()2460 double get_value() {
2461 return value;
2462 }
2463
2464
get_upper()2465 double get_upper() {
2466 return upper;
2467 }
2468
2469
get_lower()2470 double get_lower() {
2471 return lower;
2472 }
2473
get_step_increment()2474 double get_step_increment() {
2475 return step_increment;
2476 }
2477
get_page_increment()2478 double get_page_increment() {
2479 return page_increment;
2480 }
2481
get_page_size()2482 double get_page_size() {
2483 return page_size;
2484 }
2485
freeze()2486 void freeze() {
2487 frozen = true;
2488 }
2489
thaw()2490 void thaw() {
2491 frozen = false;
2492 }
2493
2494 private:
2495 double value;
2496 double lower;
2497 double upper;
2498 double step_increment;
2499 double page_increment;
2500 double page_size;
2501 boolean frozen;
2502
2503 LiVESWidget *owner;
2504
2505 };
2506
2507
qmake_mnemonic(QString qlabel)2508 LIVES_INLINE QString qmake_mnemonic(QString qlabel) {
2509 qlabel = qlabel.replace('&', "&&");
2510 qlabel = qlabel.replace('_', '&');
2511 return qlabel;
2512 }
2513
2514
qmake_underline(QString qlabel)2515 LIVES_INLINE QString qmake_underline(QString qlabel) {
2516 qlabel = qlabel.replace('&', '_');
2517 qlabel = qlabel.replace("__", "&");
2518 return qlabel;
2519 }
2520
2521
2522 class LiVESButtonBase : public LiVESWidget {
2523 public:
LiVESButtonBase()2524 LiVESButtonBase() {
2525 init();
2526 }
2527
LiVESButtonBase(QString qs)2528 LiVESButtonBase(QString qs) {
2529 init();
2530 }
2531
set_use_underline(bool use)2532 void set_use_underline(bool use) {
2533 QAbstractButton *qab = dynamic_cast<QAbstractButton *>(this);
2534 if (qab != NULL) {
2535 if (use && !use_underline) {
2536 // alter label
2537 qab->setText(qmake_mnemonic(qab->text()));
2538 } else if (!use && use_underline) {
2539 qab->setText(qmake_underline(qab->text()));
2540 }
2541 }
2542 use_underline = use;
2543 }
2544
get_use_underline()2545 bool get_use_underline() {
2546 return use_underline;
2547 }
2548
2549 private:
2550 bool use_underline;
2551
init()2552 void init() {
2553 use_underline = false;
2554 }
2555
2556 };
2557
2558
2559
2560 class LiVESToggleButton : public LiVESButtonBase, public QCheckBox {};
2561
2562
2563
2564
2565 class LiVESButton : public LiVESButtonBase, public QPushButton {
2566 public:
2567
LiVESButton()2568 LiVESButton() {
2569 init();
2570 }
2571
LiVESButton(QString qs)2572 LiVESButton(QString qs) {
2573 init();
2574 }
2575
get_layout()2576 LiVESWidget *get_layout() {
2577 if (layout == NULL) {
2578 layout = new LiVESVBox;
2579 (static_cast<QPushButton *>(this))->setLayout(dynamic_cast<QLayout *>(layout));
2580 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
2581 add_child(layout);
2582 }
2583 return layout;
2584 }
2585
2586 private:
2587 LiVESWidget *layout;
init()2588 void init() {
2589 set_type(LIVES_WIDGET_TYPE_BUTTON);
2590 }
2591
2592 };
2593
2594
2595
2596
2597 class LiVESSpinButton : public LiVESButtonBase, public QDoubleSpinBox {
2598 public:
2599
LiVESSpinButton(LiVESAdjustment * xadj,double climb_rate,uint32_t digits)2600 LiVESSpinButton(LiVESAdjustment *xadj, double climb_rate, uint32_t digits) : adj(xadj) {
2601 init();
2602
2603 adj->set_owner(this);
2604
2605 setDecimals(digits);
2606 setSingleStep(climb_rate);
2607
2608 setValue(adj->get_value());
2609 setMinimum(adj->get_lower());
2610 setMaximum(adj->get_upper());
2611
2612 }
2613
get_adj()2614 LiVESAdjustment *get_adj() {
2615 return adj;
2616 }
2617
valueChanged(double value)2618 void valueChanged(double value) {
2619 adj->freeze();
2620 adj->set_value(value);
2621 adj->thaw();
2622 }
2623
2624 private:
2625 LiVESAdjustment *adj;
2626
init()2627 void init() {
2628 set_type(LIVES_WIDGET_TYPE_SPIN_BUTTON);
2629 }
2630
2631 };
2632
2633
2634
2635
2636 class LiVESRadioButton : public LiVESButtonBase, public QRadioButton {
2637 public:
LiVESRadioButton()2638 LiVESRadioButton() {
2639 init();
2640 }
2641
LiVESRadioButton(QString qs)2642 LiVESRadioButton(QString qs) {
2643 init();
2644 }
2645
set_group(LiVESSList * xlist)2646 void set_group(LiVESSList *xlist) {
2647 slist = xlist;
2648 }
2649
get_list()2650 LiVESSList *get_list() {
2651 return slist;
2652 }
2653
2654
~LiVESRadioButton()2655 ~LiVESRadioButton() {
2656 QButtonGroup *qbg = (QButtonGroup *)lives_slist_nth_data(slist, 0);
2657 QList<QAbstractButton *> ql = qbg->buttons();
2658 if (ql.size() == 1) lives_slist_remove(slist, (livesconstpointer)qbg);
2659 }
2660
2661 private:
2662 LiVESSList *slist;
2663
init()2664 void init() {
2665 //setCheckable(true);
2666 set_type(LIVES_WIDGET_TYPE_RADIO_BUTTON);
2667 }
2668
2669 };
2670
2671
2672
2673 class LiVESCheckButton : public LiVESToggleButton {
2674 public:
2675
LiVESCheckButton()2676 LiVESCheckButton() {
2677 init();
2678 }
2679
LiVESCheckButton(QString qs)2680 LiVESCheckButton(QString qs) {
2681 init();
2682 }
2683
2684 private:
init()2685 void init() {
2686 set_type(LIVES_WIDGET_TYPE_CHECK_BUTTON);
2687 }
2688
2689 };
2690
2691
2692
2693 class LiVESButtonBox : public LiVESWidget, public QDialogButtonBox {
2694 public:
LiVESButtonBox()2695 LiVESButtonBox() {
2696 set_type(LIVES_WIDGET_TYPE_BUTTON_BOX);
2697 }
2698
2699 };
2700
2701
2702
2703 class LiVESMenuBar : public LiVESWidget, public QMenuBar {
2704 public:
LiVESMenuBar()2705 LiVESMenuBar() {
2706 set_type(LIVES_WIDGET_TYPE_MENU_BAR);
2707 }
2708
2709
reorder_child(LiVESWidget * child,int pos)2710 void reorder_child(LiVESWidget *child, int pos) {
2711 LiVESList *children = get_children();
2712 LiVESList *new_children;
2713 QMenuBar *qmenu = static_cast<QMenuBar *>(this);
2714
2715 for (int i = 0; children != NULL; i++) {
2716 if (i == pos) lives_list_append(new_children, child);
2717 else if (children->data != (livespointer)child) lives_list_append(new_children, children->data);
2718 qmenu->removeAction((QAction *)(children->data));
2719 children = children->next;
2720 }
2721
2722 children = new_children;
2723
2724 for (int i = 0; new_children != NULL; i++) {
2725 qmenu->addAction((QAction *)(new_children->data));
2726 new_children = new_children->next;
2727 }
2728
2729 set_children(new_children);
2730 }
2731
2732
2733
2734 };
2735
2736
2737
2738
2739 class LiVESMenu : public LiVESWidget, public QMenu {
2740 public:
LiVESMenu()2741 LiVESMenu() {
2742 set_type(LIVES_WIDGET_TYPE_MENU);
2743 }
2744
reorder_child(LiVESWidget * child,int pos)2745 void reorder_child(LiVESWidget *child, int pos) {
2746 LiVESList *children = get_children();
2747 LiVESList *new_children;
2748 QMenu *qmenu = static_cast<QMenu *>(this);
2749
2750 for (int i = 0; children != NULL; i++) {
2751 if (i == pos) lives_list_append(new_children, child);
2752 else if (children->data != (livespointer)child) lives_list_append(new_children, children->data);
2753 qmenu->removeAction((QAction *)(children->data));
2754 children = children->next;
2755 }
2756
2757 children = new_children;
2758
2759 for (int i = 0; new_children != NULL; i++) {
2760 qmenu->addAction((QAction *)(new_children->data));
2761 new_children = new_children->next;
2762 }
2763
2764 set_children(new_children);
2765 }
2766
2767 };
2768
2769
2770 class LiVESTornOffMenu : public LiVESMenu {
2771 public:
LiVESTornOffMenu(LiVESMenu * menu)2772 LiVESTornOffMenu(LiVESMenu *menu) {
2773 QWidget *qmenu = static_cast<QWidget *>(static_cast<QMenu *>(menu));
2774 QWidget *parentWidget = qmenu->parentWidget();
2775 QWidget *qwidget = (static_cast<QWidget *>(static_cast<QMenu *>(this)));
2776 qwidget->setParent(parentWidget, Qt::Window | Qt::Tool);
2777 qwidget->setAttribute(Qt::WA_DeleteOnClose, true);
2778 qwidget->setAttribute(Qt::WA_X11NetWmWindowTypeMenu, true);
2779 qwidget->setWindowTitle(qmenu->windowTitle());
2780 qwidget->setEnabled(qmenu->isEnabled());
2781
2782 QList<QAction *> items = qmenu->actions();
2783 for (int i = 0; i < items.count(); i++)
2784 qwidget->addAction(items.at(i));
2785
2786 set_parent(menu->get_parent());
2787
2788 if (qmenu->isVisible()) {
2789 qmenu->hide();
2790 qwidget->setVisible(true);
2791 }
2792
2793 }
2794 };
2795
2796
2797
2798
2799
2800 class LiVESMenuItem : public LiVESWidget, public QAction {
2801 public:
LiVESMenuItem(LiVESWidget * parent)2802 LiVESMenuItem(LiVESWidget *parent) : QAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2803 set_type(LIVES_WIDGET_TYPE_MENU_ITEM);
2804 }
2805
LiVESMenuItem(const QString & text,LiVESWidget * parent)2806 LiVESMenuItem(const QString &text, LiVESWidget *parent) : QAction(text,
2807 static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2808 set_type(LIVES_WIDGET_TYPE_MENU_ITEM);
2809 this->setText(text);
2810 }
2811
2812
2813
2814 };
2815
2816
2817
2818 class LiVESToolItem : public LiVESWidget, public QHBoxLayout {
2819 public:
LiVESToolItem()2820 LiVESToolItem() {
2821 init();
2822 }
2823
get_layout()2824 LiVESWidget *get_layout() {
2825 if (layout == NULL) {
2826 layout = new LiVESVBox;
2827 (static_cast<QHBoxLayout *>(this))->addLayout(dynamic_cast<QLayout *>(layout));
2828 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
2829 add_child(layout);
2830 }
2831 return layout;
2832 }
2833
2834 private:
2835 LiVESWidget *layout;
2836
init()2837 void init() {
2838 set_type(LIVES_WIDGET_TYPE_TOOL_ITEM);
2839 }
2840 };
2841
2842
2843
2844
2845 typedef LiVESMenuItem LiVESImageMenuItem;
2846
2847
2848
2849 class LiVESMenuToolButton : public LiVESToolItem, public QWidgetAction {
2850 public:
2851
LiVESMenuToolButton(const QString & text,LiVESWidget * parent,LiVESWidget * icon)2852 LiVESMenuToolButton(const QString &text, LiVESWidget *parent, LiVESWidget *icon) :
2853 QWidgetAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2854 QPushButton *qbutton = new QPushButton(text);
2855 set_type(LIVES_WIDGET_TYPE_MENU_TOOL_BUTTON);
2856 setDefaultWidget(qbutton);
2857 //setIcon(qicon);
2858 }
2859
2860 };
2861
2862
2863
2864
2865 class LiVESCheckMenuItem : public LiVESWidget, public QAction {
2866 public:
LiVESCheckMenuItem(LiVESWidget * parent)2867 LiVESCheckMenuItem(LiVESWidget *parent) : QAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2868 }
2869
LiVESCheckMenuItem(const QString & text,LiVESWidget * parent)2870 LiVESCheckMenuItem(const QString &text, LiVESWidget *parent) : QAction(text,
2871 static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2872 setText(text);
2873 }
2874
2875 private:
init()2876 void init() {
2877 set_type(LIVES_WIDGET_TYPE_CHECK_MENU_ITEM);
2878 setCheckable(true);
2879 }
2880
2881
2882 };
2883
2884
2885 class LiVESRadioMenuItem : public LiVESMenuItem {
2886 public:
2887
LiVESRadioMenuItem(LiVESWidget * parent)2888 LiVESRadioMenuItem(LiVESWidget *parent) : LiVESMenuItem(parent) {
2889 init();
2890 }
2891
LiVESRadioMenuItem(const QString & text,LiVESWidget * parent)2892 LiVESRadioMenuItem(const QString &text, LiVESWidget *parent) : LiVESMenuItem(text, parent) {
2893 init();
2894 setText(text);
2895 }
2896
2897
set_group(LiVESSList * xlist)2898 void set_group(LiVESSList *xlist) {
2899 slist = xlist;
2900 }
2901
get_list()2902 LiVESSList *get_list() {
2903 return slist;
2904 }
2905
2906
~LiVESRadioMenuItem()2907 ~LiVESRadioMenuItem() {
2908 QActionGroup *qag = const_cast<QActionGroup *>(static_cast<const QActionGroup *>(lives_slist_nth_data(slist, 0)));
2909 QList<QAction *> ql = qag->actions();
2910 if (ql.size() == 1) lives_slist_remove(slist, (livesconstpointer)qag);
2911 }
2912
2913 private:
2914 LiVESSList *slist;
2915
init()2916 void init() {
2917 setCheckable(true);
2918 set_type(LIVES_WIDGET_TYPE_RADIO_MENU_ITEM);
2919 }
2920 };
2921
2922
2923
2924
2925 class LiVESCombo : public LiVESWidget, public QComboBox {
2926 public:
LiVESCombo()2927 LiVESCombo() {
2928 set_type(LIVES_WIDGET_TYPE_COMBO);
2929 }
2930 };
2931
2932
2933 class LiVESHSeparator : public LiVESWidget, public QHBoxLayout {
2934 public:
LiVESHSeparator()2935 LiVESHSeparator() {
2936 QFrame *line = new QFrame();
2937 line->setFrameShape(QFrame::HLine);
2938 line->setFrameShadow(QFrame::Sunken);
2939 addWidget(line);
2940 set_type(LIVES_WIDGET_TYPE_HSEPARATOR);
2941 }
2942 };
2943
2944
2945
2946 class LiVESVSeparator : public LiVESWidget, public QVBoxLayout {
2947 public:
LiVESVSeparator()2948 LiVESVSeparator() {
2949 QFrame *line = new QFrame();
2950 line->setFrameShape(QFrame::VLine);
2951 line->setFrameShadow(QFrame::Sunken);
2952 addWidget(line);
2953 set_type(LIVES_WIDGET_TYPE_VSEPARATOR);
2954 }
2955 };
2956
2957
2958
2959 class LiVESTextBuffer : public LiVESWidget, public QTextDocument {
2960 public:
2961
LiVESTextBuffer()2962 LiVESTextBuffer() {
2963 insert = QTextCursor(this);
2964 }
2965
get_cursor()2966 QTextCursor get_cursor() {
2967 return insert;
2968 }
2969
2970 private:
2971 QTextCursor insert;
2972
2973 };
2974
2975
2976
2977 class LiVESTextView : public LiVESWidget, public QTextEdit {
2978 public:
2979
LiVESTextView()2980 LiVESTextView() {
2981 buff = new LiVESTextBuffer();
2982 }
2983
2984
LiVESTextView(LiVESTextBuffer * xbuff)2985 LiVESTextView(LiVESTextBuffer *xbuff) : QTextEdit(), buff(xbuff) {
2986 set_type(LIVES_WIDGET_TYPE_TEXT_VIEW);
2987 setDocument(buff);
2988 }
2989
~LiVESTextView()2990 ~LiVESTextView() {
2991 delete buff;
2992 }
2993
2994
get_buffer()2995 LiVESTextBuffer *get_buffer() {
2996 return buff;
2997 }
2998
2999 private:
3000 LiVESTextBuffer *buff;
3001
init()3002 void init() {
3003 set_type(LIVES_WIDGET_TYPE_TEXT_VIEW);
3004 setDocument(buff);
3005 }
3006
3007
3008 };
3009
3010
3011
3012 class LiVESTextMark : public LiVESWidgetObject, public QTextCursor {
3013 public:
3014
LiVESTextMark(LiVESTextBuffer * tbuff,const char * mark_name,int where,boolean left_gravity)3015 LiVESTextMark(LiVESTextBuffer *tbuff, const char *mark_name,
3016 int where, boolean left_gravity) : QTextCursor(tbuff), name(mark_name), lgrav(left_gravity) {
3017 (static_cast<QTextCursor *>(this))->setPosition(where);
3018 }
3019
~LiVESTextMark()3020 ~LiVESTextMark() {
3021 delete name;
3022 }
3023
get_name()3024 QString get_name() {
3025 return name;
3026 }
3027
3028 private:
3029 const char *name;
3030 boolean lgrav;
3031
3032 };
3033
3034
3035
3036 class LiVESRange : public LiVESWidget {
3037 Q_OBJECT
3038
3039 public:
LiVESRange(LiVESAdjustment * adj)3040 LiVESRange(LiVESAdjustment *adj) {
3041 init(adj);
3042 }
3043
init(LiVESAdjustment * adj)3044 virtual void init(LiVESAdjustment *adj) {}
3045
get_adj()3046 LiVESAdjustment *get_adj() {
3047 return adj;
3048 }
3049
3050 public slots:
valueChanged(int value)3051 void valueChanged(int value) {
3052 adj->freeze();
3053 adj->set_value(value);
3054 adj->thaw();
3055 }
3056
3057 private:
3058 LiVESAdjustment *adj;
3059
3060 };
3061
3062
3063 class LiVESScale : public LiVESRange, public QSlider {
3064 // TODO - add a label
3065 public:
LiVESScale(Qt::Orientation,LiVESAdjustment * xadj)3066 LiVESScale(Qt::Orientation, LiVESAdjustment *xadj) : LiVESRange(xadj) {
3067 set_type(LIVES_WIDGET_TYPE_SCALE);
3068 }
3069
init(LiVESAdjustment * adj)3070 void init(LiVESAdjustment *adj) {
3071 adj->set_owner(this);
3072 setMinimum(adj->get_lower());
3073 setMaximum(adj->get_upper());
3074 setValue(adj->get_value());
3075 setSingleStep(adj->get_step_increment());
3076 setPageStep(adj->get_page_increment());
3077 }
3078 };
3079
3080
3081 class LiVESScrollbar : public LiVESRange, public QScrollBar {
3082 public:
LiVESScrollbar(Qt::Orientation,LiVESAdjustment * xadj)3083 LiVESScrollbar(Qt::Orientation, LiVESAdjustment *xadj) : LiVESRange(xadj) {
3084 set_type(LIVES_WIDGET_TYPE_SCROLLBAR);
3085 }
3086
init(LiVESAdjustment * adj)3087 void init(LiVESAdjustment *adj) {
3088 adj->set_owner(this);
3089 setMinimum(adj->get_lower());
3090 setMaximum(adj->get_upper());
3091 setValue(adj->get_value());
3092 setSingleStep(adj->get_step_increment());
3093 setPageStep(adj->get_page_increment());
3094 }
3095
3096 };
3097
3098 typedef LiVESScrollbar LiVESHScrollbar;
3099
3100
3101 class LiVESEntry : public LiVESWidget, public QLineEdit {
3102 public:
LiVESEntry()3103 LiVESEntry() {
3104 set_type(LIVES_WIDGET_TYPE_ENTRY);
3105 }
3106 };
3107
3108
3109 class LiVESProgressBar : public LiVESWidget, public QProgressBar {
3110 public:
LiVESProgressBar()3111 LiVESProgressBar() {
3112 set_type(LIVES_WIDGET_TYPE_PROGRESS_BAR);
3113 }
3114 };
3115
3116
3117 class LiVESPaned : public LiVESWidget, public QSplitter {
3118 public:
3119
LiVESPaned()3120 LiVESPaned() {
3121 set_type(LIVES_WIDGET_TYPE_PANED);
3122 }
3123 };
3124
3125
3126 class LiVESLabel : public LiVESWidget, public QLabel {
3127 public:
LiVESLabel(QString qstring)3128 LiVESLabel(QString qstring) {
3129 set_type(LIVES_WIDGET_TYPE_LABEL);
3130 }
3131
get_mnemonic_widget()3132 LiVESWidget *get_mnemonic_widget() {
3133 return mnemonicw;
3134 }
3135
set_mnemonic_widget(LiVESWidget * widget)3136 void set_mnemonic_widget(LiVESWidget *widget) {
3137 mnemonicw = widget;
3138 }
3139
set_owner(LiVESWidget * xowner)3140 void set_owner(LiVESWidget *xowner) {
3141 owner = xowner;
3142 }
3143
get_owner()3144 LiVESWidget *get_owner() {
3145 return owner;
3146 }
3147
set_text(QString text)3148 void set_text(QString text) {
3149 // if we have an owner, update owner text
3150 // TODO
3151 }
3152
3153
3154 private:
3155 LiVESWidget *mnemonicw;
3156 LiVESWidget *owner; // TODO
3157 };
3158
3159
3160 class LiVESRuler : public LiVESWidget, public QSlider {
3161 public:
LiVESRuler()3162 LiVESRuler() {
3163 set_type(LIVES_WIDGET_TYPE_RULER);
3164 }
3165 };
3166
3167
3168
3169
3170 class LiVESScrolledWindow : public LiVESWidget, public QScrollArea {
3171 public:
LiVESScrolledWindow(LiVESAdjustment * xhadj,LiVESAdjustment * xvadj)3172 LiVESScrolledWindow(LiVESAdjustment *xhadj, LiVESAdjustment *xvadj) : hadj(xhadj), vadj(xvadj) {
3173 set_type(LIVES_WIDGET_TYPE_SCROLLED_WINDOW);
3174 hadj->set_owner(this);
3175 vadj->set_owner(this);
3176
3177 QScrollBar *hs = horizontalScrollBar();
3178 hs->setMinimum(hadj->get_lower());
3179 hs->setMaximum(hadj->get_upper());
3180 hs->setValue(hadj->get_value());
3181 hs->setSingleStep(hadj->get_step_increment());
3182 hs->setPageStep(hadj->get_page_increment());
3183
3184 QScrollBar *vs = verticalScrollBar();
3185 vs->setMinimum(vadj->get_lower());
3186 vs->setMaximum(vadj->get_upper());
3187 vs->setValue(vadj->get_value());
3188 vs->setSingleStep(vadj->get_step_increment());
3189 vs->setPageStep(vadj->get_page_increment());
3190
3191 }
3192
get_hadj()3193 LiVESAdjustment *get_hadj() {
3194 return hadj;
3195 }
3196
get_vadj()3197 LiVESAdjustment *get_vadj() {
3198 return vadj;
3199 }
3200
3201 private:
3202 LiVESAdjustment *hadj;
3203 LiVESAdjustment *vadj;
3204
3205 };
3206
3207
3208
3209
3210
3211 class LiVESToolButton : public LiVESToolItem, public QToolButton {
3212 public:
3213
LiVESToolButton(LiVESWidget * icon_widget,const char * label)3214 LiVESToolButton(LiVESWidget *icon_widget, const char *label) {
3215 set_type(LIVES_WIDGET_TYPE_TOOL_BUTTON);
3216 set_icon_widget(icon_widget);
3217 layout = new LiVESVBox;
3218 QBoxLayout *ql = static_cast<QVBoxLayout *>(layout);
3219 ql->setParent(static_cast<QToolButton *>(this));
3220 add_child(layout);
3221 if (label != NULL) {
3222 LiVESWidget *widget = new LiVESLabel(label);
3223 layout->add_child(widget);
3224 label_widget = dynamic_cast<LiVESLabel *>(widget);
3225 (static_cast<QBoxLayout *>(layout))->addWidget(static_cast<QLabel *>(label_widget));
3226 } else label_widget = NULL;
3227 }
3228
3229
set_icon_widget(LiVESWidget * widget)3230 void set_icon_widget(LiVESWidget *widget) {
3231 if (icon_widget != NULL) remove_child(icon_widget);
3232 icon_widget = NULL;
3233 QImage *qim = NULL;
3234 if (widget != NULL) qim = dynamic_cast<QImage *>(widget);
3235 if (qim) {
3236 QPixmap *qpx = new QPixmap();
3237 qpx->convertFromImage(*qim);
3238 QIcon *qi = new QIcon(*qpx);
3239 setIcon(*qi);
3240 setIconSize(LIVES_ICON_SIZE_SMALL_TOOLBAR);
3241 icon_widget = widget;
3242 add_child(widget);
3243 }
3244 }
3245
3246
set_label_widget(LiVESWidget * widget)3247 void set_label_widget(LiVESWidget *widget) {
3248 if (label_widget != NULL) {
3249 layout->remove_child(static_cast<LiVESWidget *>(label_widget));
3250 layout->removeWidget(static_cast<LiVESWidget *>(label_widget));
3251 }
3252 if (widget != NULL) {
3253 layout->addWidget(widget);
3254 label_widget = dynamic_cast<LiVESLabel *>(widget);
3255 layout->add_child(label_widget);
3256 label_widget->set_owner(this);
3257 } else label_widget = NULL;
3258 }
3259
3260
set_use_underline(bool use)3261 void set_use_underline(bool use) {
3262 QAbstractButton *qab = dynamic_cast<QAbstractButton *>(this);
3263 if (qab != NULL) {
3264 if (use && !use_underline) {
3265 // alter label
3266 qab->setText(qmake_mnemonic(qab->text()));
3267 } else if (!use && use_underline) {
3268 qab->setText(qmake_underline(qab->text()));
3269 }
3270 }
3271 use_underline = use;
3272 }
3273
get_use_underline()3274 bool get_use_underline() {
3275 return use_underline;
3276 }
3277
3278 private:
3279 bool use_underline;
3280
init()3281 void init() {
3282 use_underline = false;
3283 }
3284
3285 private:
3286 LiVESWidget *icon_widget;
3287 LiVESLabel *label_widget;
3288 LiVESVBox *layout;
3289
3290 };
3291
3292
3293
3294
3295
3296
3297
3298 typedef class LiVESWindow LiVESWindow;
3299
3300 class LiVESAccelGroup {
3301 public:
3302 void add_all_accelerators(LiVESWidgetObject *window);
3303 void add_widget(LiVESWidgetObject *window);
3304 void remove_all_accelerators(LiVESWidgetObject *window);
3305 void remove_widget(LiVESWidgetObject *window);
3306
3307 void connect(uint32_t key, LiVESXModifierType mod, LiVESAccelFlags flags, LiVESWidgetClosure *closure);
3308 void disconnect(LiVESWidgetClosure *closure);
3309
3310 ~LiVESAccelGroup();
3311
3312 private:
3313 QList<LiVESWidgetObject *>widgets;
3314 QList<LiVESAccel *>accels;
3315
3316
3317 };
3318
3319
3320
3321
add_accel_group(LiVESAccelGroup * group)3322 void LiVESWidgetObject::add_accel_group(LiVESAccelGroup *group) {
3323 accel_groups.push_back(group);
3324 group->add_all_accelerators(this);
3325 group->add_widget(this);
3326 }
3327
3328
3329
remove_accel_group(LiVESAccelGroup * group)3330 boolean LiVESWidgetObject::remove_accel_group(LiVESAccelGroup *group) {
3331 if (accel_groups.removeAll(group) > 0) {
3332 group->remove_all_accelerators(this);
3333 group->remove_widget(this);
3334 return TRUE;
3335 }
3336 return FALSE;
3337 }
3338
3339
3340
remove_accels(LiVESAccelGroup * group,uint32_t key,LiVESXModifierType mods)3341 boolean LiVESWidgetObject::remove_accels(LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mods) {
3342 bool ret = false;
3343 QKeySequence ks = make_qkey_sequence(key, mods);
3344
3345 QList<LiVESAccel *>::iterator it = accels.begin();
3346 while (it != accels.end()) {
3347 if (((LiVESAccel *)*it)->group == group && ((LiVESAccel *)*it)->ks == ks) {
3348 remove_accel((LiVESAccel *)*it);
3349 ret = true;
3350 } else
3351 ++it;
3352 }
3353 return ret;
3354 }
3355
3356
get_accels_for(LiVESAccelGroup * group,QKeySequence ks)3357 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(LiVESAccelGroup *group, QKeySequence ks) {
3358 QList<LiVESAccel *> ql;
3359 for (int i = 0; i < accels.size(); i++) {
3360 if (accels[i]->group == group && accels[i]->ks == ks) ql.push_back(accels[i]);
3361 }
3362 return ql;
3363 }
3364
3365
3366
3367 class LiVESWindow : public LiVESWidget {};
3368
3369 typedef int LiVESWindowPosition;
3370 #define LIVES_WIN_POS_DEFAULT 0
3371 #define LIVES_WIN_POS_CENTER_ALWAYS 1
3372
3373
3374 class LiVESMainWindow : public LiVESWindow, public QMainWindow {
3375 public:
LiVESMainWindow()3376 LiVESMainWindow() {
3377 set_type(LIVES_WIDGET_TYPE_MAIN_WINDOW);
3378 set_position(LIVES_WIN_POS_DEFAULT);
3379 }
3380
get_layout()3381 LiVESWidget *get_layout() {
3382 if (layout == NULL) {
3383 layout = new LiVESVBox;
3384 (static_cast<QMainWindow *>(this))->setLayout(dynamic_cast<QLayout *>(layout));
3385 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
3386 add_child(layout);
3387 }
3388 return layout;
3389 }
3390
set_position(LiVESWindowPosition xpos)3391 void set_position(LiVESWindowPosition xpos) {
3392 pos = xpos;
3393 }
3394
get_position()3395 LiVESWindowPosition get_position() {
3396 return pos;
3397 }
3398
3399
3400 private:
3401 LiVESWidget *layout;
3402 LiVESWindowPosition pos;
3403
3404 };
3405
3406
3407
add_all_accelerators(LiVESWidgetObject * object)3408 void LiVESAccelGroup::add_all_accelerators(LiVESWidgetObject *object) {
3409 for (int i = 0; i < accels.size(); i++) {
3410 object->add_accel(accels.at(i));
3411 }
3412 }
3413
add_widget(LiVESWidgetObject * window)3414 void LiVESAccelGroup::add_widget(LiVESWidgetObject *window) {
3415 widgets.push_back(window);
3416 }
3417
3418
remove_all_accelerators(LiVESWidgetObject * object)3419 void LiVESAccelGroup::remove_all_accelerators(LiVESWidgetObject *object) {
3420 while (accels.size() > 0) {
3421 object->remove_accel(accels.at(0));
3422 }
3423 }
3424
3425
remove_widget(LiVESWidgetObject * window)3426 void LiVESAccelGroup::remove_widget(LiVESWidgetObject *window) {
3427 widgets.removeAll(window);
3428 }
3429
3430
~LiVESAccelGroup()3431 LiVESAccelGroup::~LiVESAccelGroup() {
3432 while (widgets.size() > 0) {
3433 remove_all_accelerators(widgets.at(0));
3434 }
3435 }
3436
3437
3438 class LiVESVLayout: public LiVESWidget, public QVBoxLayout {};
3439
3440 class LiVESDialog : public LiVESWindow, public QDialog {
3441 public:
LiVESDialog()3442 LiVESDialog() {
3443 QDialog *qd = static_cast<QDialog *>(this);
3444 QVBoxLayout *layout = new QVBoxLayout;
3445 layout->setMargin(0);
3446 qd->setLayout(layout);
3447
3448 contentArea = new LiVESVLayout();
3449 QVBoxLayout *ca = dynamic_cast<QVBoxLayout *>(contentArea);
3450 ca->setMargin(0);
3451 layout->insertLayout(0, ca);
3452
3453 actionArea = new LiVESButtonBox;
3454 QDialogButtonBox *bb = dynamic_cast<QDialogButtonBox *>(actionArea);
3455 bb->setContentsMargins(0, 0, 0, 0);
3456 layout->addWidget(bb);
3457
3458 set_type(LIVES_WIDGET_TYPE_DIALOG);
3459
3460 add_child(actionArea);
3461 add_child(contentArea);
3462
3463 }
3464
get_content_area()3465 LiVESWidget *get_content_area() {
3466 return contentArea;
3467 }
3468
get_action_area()3469 LiVESWidget *get_action_area() {
3470 return actionArea;
3471 }
3472
get_layout()3473 LiVESWidget *get_layout() {
3474 if (layout == NULL) {
3475 layout = new LiVESVBox;
3476 (static_cast<QDialog *>(this))->setLayout(dynamic_cast<QLayout *>(layout));
3477 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
3478 add_child(layout);
3479 }
3480 return layout;
3481 }
3482
3483 private:
3484 LiVESWidget *layout;
3485 LiVESWidget *contentArea;
3486 LiVESWidget *actionArea;
3487 };
3488
3489
3490 typedef int LiVESDialogFlags;
3491 typedef QMessageBox::Icon LiVESMessageType;
3492
3493 #define LIVES_MESSAGE_INFO QMessageBox::Information
3494 #define LIVES_MESSAGE_WARNING QMessageBox::Warning
3495 #define LIVES_MESSAGE_QUESTION QMessageBox::Question
3496 #define LIVES_MESSAGE_ERROR QMessageBox::Warning
3497 #define LIVES_MESSAGE_OTHER QMessageBox::NoIcon
3498
3499 typedef int LiVESButtonsType;
3500 #define LIVES_BUTTONS_NONE 0
3501
3502 class LiVESMessageDialog : public LiVESWindow, public QMessageBox {
3503 public:
LiVESMessageDialog()3504 LiVESMessageDialog() {
3505 QMessageBox *qd = static_cast<QMessageBox *>(this);
3506 QVBoxLayout *layout = new QVBoxLayout;
3507 layout->setMargin(0);
3508 qd->setLayout(layout);
3509
3510 contentArea = new LiVESVLayout();
3511 QVBoxLayout *ca = dynamic_cast<QVBoxLayout *>(contentArea);
3512 ca->setMargin(0);
3513 layout->insertLayout(0, ca);
3514
3515 actionArea = new LiVESButtonBox;
3516 QDialogButtonBox *bb = dynamic_cast<QDialogButtonBox *>(actionArea);
3517 bb->setContentsMargins(0, 0, 0, 0);
3518 layout->addWidget(bb);
3519
3520 set_type(LIVES_WIDGET_TYPE_DIALOG);
3521
3522 add_child(actionArea);
3523 add_child(contentArea);
3524
3525 }
3526
get_content_area()3527 LiVESWidget *get_content_area() {
3528 return contentArea;
3529 }
3530
get_action_area()3531 LiVESWidget *get_action_area() {
3532 return actionArea;
3533 }
3534
get_layout()3535 LiVESWidget *get_layout() {
3536 if (layout == NULL) {
3537 layout = new LiVESVBox;
3538 (static_cast<QDialog *>(this))->setLayout(dynamic_cast<QLayout *>(layout));
3539 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
3540 add_child(layout);
3541 }
3542 return layout;
3543 }
3544
3545 private:
3546 LiVESWidget *layout;
3547 LiVESWidget *contentArea;
3548 LiVESWidget *actionArea;
3549 };
3550
3551
3552 typedef void LiVESAboutDialog;
3553
3554
3555 class LiVESAlignment: public LiVESWidget, public QGridLayout {
3556 public:
3557 float xalign, yalign, xscale, yscale;
3558
LiVESAlignment(float xxalign,float yyalign,float xxscale,float yyscale)3559 LiVESAlignment(float xxalign, float yyalign, float xxscale, float yyscale) :
3560 xalign(xxalign),
3561 yalign(yyalign),
3562 xscale(xxscale),
3563 yscale(yyscale) {
3564 set_type(LIVES_WIDGET_TYPE_ALIGNMENT);
3565 }
3566
set_alignment(float xxalign,float yyalign,float xxscale,float yyscale)3567 void set_alignment(float xxalign, float yyalign, float xxscale, float yyscale) {
3568 xalign = xxalign;
3569 yalign = yyalign;
3570 xscale = xxscale;
3571 yscale = yyscale;
3572
3573 // do something with layout spacers
3574 // or setContentsmargins()
3575
3576 }
3577
3578
3579 };
3580
3581
3582 class LiVESImage : public LiVESWidget, public QImage {
3583 public:
3584
LiVESImage()3585 LiVESImage() {
3586 init();
3587 }
3588
LiVESImage(QImage * lim)3589 LiVESImage(QImage *lim) {
3590 init();
3591 };
3592
LiVESImage(int width,int height,QImage::Format fmt)3593 LiVESImage(int width, int height, QImage::Format fmt) {
3594 init();
3595 }
3596
LiVESImage(uint8_t * data,int width,int height,int bpl,QImage::Format fmt,QImageCleanupFunction cleanupFunction,livespointer cleanupInfo)3597 LiVESImage(uint8_t *data, int width, int height, int bpl, QImage::Format fmt, QImageCleanupFunction cleanupFunction,
3598 livespointer cleanupInfo) {
3599 init();
3600 }
3601
3602 private:
init()3603 void init() {
3604 set_type(LIVES_WIDGET_TYPE_IMAGE);
3605 }
3606
3607 };
3608
3609
3610
3611
3612 class LiVESArrow : public LiVESImage {
3613 public:
LiVESArrow(QImage * image)3614 LiVESArrow(QImage *image) {
3615 set_type(LIVES_WIDGET_TYPE_ARROW);
3616 }
3617 };
3618
3619 // rendertypes
3620 #define LIVES_CELL_RENDERER_TEXT 1
3621 #define LIVES_CELL_RENDERER_SPIN 2
3622 #define LIVES_CELL_RENDERER_TOGGLE 3
3623 #define LIVES_CELL_RENDERER_PIXBUF 4
3624
3625
3626 typedef struct {
3627 const char *attr;
3628 int col;
3629 } tvattrcol;
3630
3631 typedef QHeaderView::ResizeMode LiVESTreeViewColumnSizing;
3632
3633 #define LIVES_TREE_VIEW_COLUMN_GROW_ONLY QHeaderView::Stretch
3634 #define LIVES_TREE_VIEW_COLUMN_AUTOSIZE QHeaderView::ResizeToContents
3635 #define LIVES_TREE_VIEW_COLUMN_FIXED QHeaderView::Fixed
3636
3637 typedef class LiVESTreeView LiVESTreeView;
3638 typedef LiVESTreeView LiVESTreeSelection;
3639
3640
3641 class LiVESTreeViewColumn : public LiVESWidgetObject, public QStyledItemDelegate {
3642 friend LiVESTreeView;
3643
3644 public:
3645
LiVESTreeViewColumn(int rendertype)3646 LiVESTreeViewColumn(int rendertype) {
3647 fwidth = -1;
3648 }
3649
set_title(const char * xtitle)3650 void set_title(const char *xtitle) {
3651 title = strdup(xtitle);
3652 }
3653
set_expand(boolean xexpand)3654 void set_expand(boolean xexpand) {
3655 expand = xexpand;
3656 }
3657
add_attribute(const char * attr,int col)3658 void add_attribute(const char *attr, int col) {
3659 tvattrcol *attrcol = new tvattrcol;
3660 attrcol->attr = strdup(attr);
3661 attrcol->col = col;
3662 attributes.push_back(attrcol);
3663 }
3664
set_sizing(LiVESTreeViewColumnSizing xsizing)3665 void set_sizing(LiVESTreeViewColumnSizing xsizing) {
3666 sizing = xsizing;
3667 }
3668
3669
set_fixed_width(int xfwidth)3670 void set_fixed_width(int xfwidth) {
3671 fwidth = xfwidth;
3672 }
3673
3674
get_attributes()3675 QList<tvattrcol *> get_attributes() {
3676 return attributes;
3677 }
3678
3679
~LiVESTreeViewColumn()3680 ~LiVESTreeViewColumn() {
3681 delete title;
3682 for (int i = 0; i < attributes.size(); i++) {
3683 delete attributes[i]->attr;
3684 }
3685 }
3686
3687
3688 protected:
3689 int fwidth;
3690 int rendertype;
3691 LiVESTreeViewColumnSizing sizing;
3692 QList<tvattrcol *>attributes;
3693 const char *title;
3694 boolean expand;
3695 };
3696
3697
3698 typedef LiVESTreeViewColumn LiVESCellRenderer;
3699
3700
3701 typedef QAbstractItemView::SelectionMode LiVESSelectionMode;
3702 #define LIVES_SELECTION_NONE QAbstractItemView::NoSelection
3703 #define LIVES_SELECTION_SINGLE QAbstractItemView::SingleSelection
3704 #define LIVES_SELECTION_MULTIPLE QAbstractItemView::MultiSelection
3705
3706
3707 typedef class LiVESTreeStore LiVESTreeStore;
3708
3709
3710 class LiVESTreeModel : public LiVESWidgetObject, public QStandardItemModel {
3711 friend LiVESTreeStore;
3712
3713 public:
3714
to_qsimodel()3715 QStandardItemModel *to_qsimodel() {
3716 QStandardItemModel *qsim = static_cast<QStandardItemModel *>(this);
3717 QVariant qv = QVariant::fromValue(static_cast<LiVESWidgetObject *>(this));
3718 qsim->setProperty("LiVESWidgetObject", qv);
3719 return qsim;
3720 }
3721
get_coltype(int index)3722 int get_coltype(int index) {
3723 return coltypes[index];
3724 }
3725
3726 void set_tree_widget(LiVESTreeView *twidget);
3727 QTreeWidget *get_qtree_widget();
3728
3729 protected:
set_coltypes(int ncols,int * types)3730 void set_coltypes(int ncols, int *types) {
3731 for (int i = 0; i < ncols; i++) {
3732 coltypes.append(types[i]);
3733 }
3734 }
3735
3736
3737 private:
3738 LiVESTreeView *widget;
3739 QList<int> coltypes;
3740
3741 };
3742
3743
3744 typedef LiVESTreeModel LiVESListModel;
3745
3746
3747 class LiVESTreeView : public LiVESWidget, public QTreeWidget {
3748 //Q_OBJECT
3749
3750 public:
LiVESTreeView()3751 LiVESTreeView() {
3752 set_type(LIVES_WIDGET_TYPE_TREE_VIEW);
3753
3754 QAbstractSlider *sbar = static_cast<QAbstractSlider *>(horizontalScrollBar());
3755 hadj = new LiVESAdjustment(sbar->value(), sbar->minimum(), sbar->maximum(), sbar->singleStep(), sbar->pageStep(), -1.);
3756 hadj->set_owner(this);
3757 sbar->connect(sbar, SIGNAL(valueChanged(int)), static_cast<QObject *>(static_cast<LiVESWidgetObject *>(this)),
3758 SLOT(hvalue_changed(int)));
3759
3760 sbar = static_cast<QAbstractSlider *>(verticalScrollBar());
3761 vadj = new LiVESAdjustment(sbar->value(), sbar->minimum(), sbar->maximum(), sbar->singleStep(), sbar->pageStep(), -1.);
3762 vadj->set_owner(this);
3763 sbar->connect(sbar, SIGNAL(valueChanged(int)), static_cast<QObject *>(static_cast<LiVESWidgetObject *>(this)),
3764 SLOT(vvalue_changed(int)));
3765
3766 }
3767
set_model(LiVESTreeModel * xmodel)3768 void set_model(LiVESTreeModel *xmodel) {
3769 model = xmodel;
3770 xmodel->set_tree_widget(this);
3771 QStandardItemModel *qmodel = xmodel->to_qsimodel();
3772 (static_cast<QAbstractItemView *>(this))->setModel(static_cast<QAbstractItemModel *>(qmodel));
3773 }
3774
get_model()3775 LiVESTreeModel *get_model() {
3776 return model;
3777 }
3778
3779
3780
append_column(LiVESTreeViewColumn * col)3781 void append_column(LiVESTreeViewColumn *col) {
3782 // make QList from data in column x
3783
3784 // get stuff from attributes
3785 QList<tvattrcol *> ql = col->get_attributes();
3786 QList<QStandardItem *> qvals;
3787 QStandardItemModel *qmodel = model->to_qsimodel();
3788
3789 int attrcol;
3790
3791 for (int i = 0; i < ql.size(); i++) {
3792 attrcol = ql[i]->col;
3793 if (!strcmp(ql[i]->attr, "text")) {
3794 // TODO
3795 // make QList of QString from model col
3796 qmodel->appendColumn(qvals);
3797 }
3798
3799 else if (!strcmp(ql[i]->attr, "pixbuf")) {
3800 // make QList of QIcons from model col
3801 qmodel->appendColumn(qvals);
3802 }
3803
3804 else if (!strcmp(ql[i]->attr, "active")) {
3805 // make QList of checkable from model col
3806 qmodel->appendColumn(qvals);
3807 }
3808 }
3809
3810 int newcol = qmodel->columnCount();
3811 QTreeView *qtv = static_cast<QTreeView *>(this);
3812 if (col->fwidth != -1) {
3813 qtv->setColumnWidth(newcol, col->fwidth);
3814 }
3815
3816 QHeaderView *qv = (static_cast<QTreeView *>(this))->header();
3817 qv->setSectionResizeMode(newcol, col->sizing);
3818
3819 //resizeColumnToContents()
3820
3821 }
3822
get_hadj()3823 LiVESAdjustment *get_hadj() {
3824 return hadj;
3825 }
3826
get_vadj()3827 LiVESAdjustment *get_vadj() {
3828 return vadj;
3829 }
3830
3831
3832 /* public slots:
3833
3834 void hvalue_changed(int newval) {
3835 hadj->freeze();
3836 hadj->set_value(newval);
3837 hadj->thaw();
3838 }
3839
3840 void vvalue_changed(int newval) {
3841 vadj->freeze();
3842 vadj->set_value(newval);
3843 vadj->thaw();
3844 }
3845 */
3846
3847 private:
3848 LiVESTreeModel *model;
3849 LiVESAdjustment *hadj, *vadj;
3850 };
3851
3852
3853 #define LIVES_COL_TYPE_STRING 1
3854 #define LIVES_COL_TYPE_INT 2
3855 #define LIVES_COL_TYPE_UINT 3
3856 #define LIVES_COL_TYPE_BOOLEAN 4
3857 #define LIVES_COL_TYPE_PIXBUF 5
3858
3859
3860 typedef QTreeWidgetItem LiVESTreeIter;
3861
set_tree_widget(LiVESTreeView * twidget)3862 void LiVESTreeModel::set_tree_widget(LiVESTreeView *twidget) {
3863 widget = twidget;
3864 }
3865
get_qtree_widget()3866 QTreeWidget *LiVESTreeModel::get_qtree_widget() {
3867 return static_cast<QTreeWidget *>(widget);
3868 }
3869
3870
3871
3872 class LiVESTreeStore : public LiVESTreeModel {
3873 public:
LiVESTreeStore(int ncols,int * types)3874 LiVESTreeStore(int ncols, int *types) {}
3875
3876 };
3877
3878
3879 class LiVESListStore : public LiVESListModel {
3880 public:
LiVESListStore(int ncols,int * types)3881 LiVESListStore(int ncols, int *types) {}
3882
3883 };
3884
3885
3886
3887
3888
set_value(double newval)3889 void LiVESAdjustment::set_value(double newval) {
3890 if (newval != value) {
3891 value = newval;
3892
3893 if (frozen) return;
3894
3895 if (LIVES_IS_SCALE(owner)) {
3896 (dynamic_cast<QAbstractSlider *>(owner))->setValue(newval);
3897 } else if (LIVES_IS_SCROLLBAR(owner)) {
3898 (dynamic_cast<QScrollBar *>(owner))->setValue(newval);
3899 } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3900 //
3901 (dynamic_cast<QDoubleSpinBox *>(owner))->setValue(newval);
3902 } else if (LIVES_IS_TREE_VIEW(owner)) {
3903 if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3904 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setValue(newval);
3905 } else {
3906 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setValue(newval);
3907 }
3908 } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3909 if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3910 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setValue(newval);
3911 } else {
3912 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setValue(newval);
3913 }
3914 }
3915 }
3916 }
3917
3918
set_upper(double newval)3919 void LiVESAdjustment::set_upper(double newval) {
3920 if (newval != upper) {
3921 upper = newval;
3922
3923 if (frozen) return;
3924
3925 if (LIVES_IS_SCALE(owner)) {
3926 (dynamic_cast<QAbstractSlider *>(owner))->setMaximum(newval);
3927 } else if (LIVES_IS_SCROLLBAR(owner)) {
3928 //
3929 (dynamic_cast<QScrollBar *>(owner))->setMaximum(newval);
3930 } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3931 //
3932 (dynamic_cast<QDoubleSpinBox *>(owner))->setMaximum(newval);
3933 } else if (LIVES_IS_TREE_VIEW(owner)) {
3934 if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3935 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMaximum(newval);
3936 } else {
3937 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMaximum(newval);
3938 }
3939 } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3940 if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3941 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMaximum(newval);
3942 } else {
3943 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMaximum(newval);
3944 }
3945 }
3946 }
3947
3948
3949 }
3950
3951
3952
set_lower(double newval)3953 void LiVESAdjustment::set_lower(double newval) {
3954 if (newval != lower) {
3955 lower = newval;
3956 if (frozen) return;
3957
3958 if (LIVES_IS_SCALE(owner)) {
3959 (dynamic_cast<QAbstractSlider *>(owner))->setMinimum(newval);
3960 } else if (LIVES_IS_SCROLLBAR(owner)) {
3961 //
3962 (dynamic_cast<QScrollBar *>(owner))->setMinimum(newval);
3963 } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3964 //
3965 (dynamic_cast<QDoubleSpinBox *>(owner))->setMinimum(newval);
3966 } else if (LIVES_IS_TREE_VIEW(owner)) {
3967 if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3968 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMinimum(newval);
3969 } else {
3970 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMinimum(newval);
3971 }
3972 } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3973 if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3974 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMinimum(newval);
3975 } else {
3976 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMinimum(newval);
3977 }
3978 }
3979 }
3980 }
3981
3982
3983
set_step_increment(double newval)3984 void LiVESAdjustment::set_step_increment(double newval) {
3985 if (newval != step_increment) {
3986 step_increment = newval;
3987
3988 if (frozen) return;
3989
3990 if (LIVES_IS_SCALE(owner)) {
3991 (dynamic_cast<QAbstractSlider *>(owner))->setSingleStep(newval);
3992 } else if (LIVES_IS_SCROLLBAR(owner)) {
3993 //
3994 (dynamic_cast<QScrollBar *>(owner))->setSingleStep(newval);
3995 } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3996 //
3997 (dynamic_cast<QDoubleSpinBox *>(owner))->setSingleStep(newval);
3998 } else if (LIVES_IS_TREE_VIEW(owner)) {
3999 if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
4000 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setSingleStep(newval);
4001 } else {
4002 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setSingleStep(newval);
4003 }
4004 } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
4005 if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
4006 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setSingleStep(newval);
4007 } else {
4008 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setSingleStep(newval);
4009 }
4010 }
4011 }
4012 }
4013
4014
set_page_increment(double newval)4015 void LiVESAdjustment::set_page_increment(double newval) {
4016 if (newval != page_increment) {
4017 page_increment = newval;
4018
4019 if (frozen) return;
4020
4021 if (LIVES_IS_SCALE(owner)) {
4022 (dynamic_cast<QAbstractSlider *>(owner))->setPageStep(newval);
4023 } else if (LIVES_IS_SCROLLBAR(owner)) {
4024 //
4025 (dynamic_cast<QScrollBar *>(owner))->setPageStep(newval);
4026 } else if (LIVES_IS_TREE_VIEW(owner)) {
4027 if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
4028 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setPageStep(newval);
4029 } else {
4030 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setPageStep(newval);
4031 }
4032 } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
4033 if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
4034 (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setPageStep(newval);
4035 } else {
4036 (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setPageStep(newval);
4037 }
4038 }
4039 }
4040 }
4041
4042
set_page_size(double newval)4043 void LiVESAdjustment::set_page_size(double newval) {
4044 // TODO
4045 if (newval != page_size) {
4046 page_size = newval;
4047
4048 if (frozen) return;
4049 }
4050 }
4051
4052
4053
4054 class LiVESTable : public LiVESWidget, public QGridLayout {
4055
4056 public:
LiVESTable()4057 LiVESTable() {
4058 set_type(LIVES_WIDGET_TYPE_TABLE);
4059 }
4060
4061
4062 private:
4063 LiVESWidget *layout;
4064
4065 };
4066
4067
4068 typedef QWindow LiVESXWindow;
4069
4070 typedef class LiVESImage LiVESPixbuf;
4071
4072 typedef LiVESWidget LiVESEditable;
4073 typedef LiVESWidget LiVESContainer;
4074 typedef LiVESWidget LiVESMenuShell;
4075 typedef LiVESWidget LiVESBin;
4076
4077 typedef QSlider LiVESScaleButton; // TODO - create
4078 typedef void LiVESExpander; // TODO - create
4079
4080
qt_jpeg_save(LiVESPixbuf * pixbuf,const char * fname,LiVESError ** errptr,int quality)4081 void qt_jpeg_save(LiVESPixbuf *pixbuf, const char *fname, LiVESError **errptr, int quality) {
4082 #ifdef IS_MINGW
4083 QImageWriter qiw(QString::fromUtf8(fname), "jpeg");
4084 #else
4085 QImageWriter qiw(QString::fromLocal8Bit(fname), "jpeg");
4086 #endif
4087 qiw.setQuality(quality);
4088 if (!qiw.write(static_cast<QImage>(*pixbuf))) {
4089 if (errptr != NULL) {
4090 *errptr = (LiVESError *)malloc(sizeof(LiVESError));
4091 (*errptr)->code = qiw.error();
4092 (*errptr)->message = strdup(qiw.errorString().toUtf8().constData());
4093 }
4094 }
4095 }
4096
4097
qt_png_save(LiVESPixbuf * pixbuf,const char * fname,LiVESError ** errptr,int cmp)4098 void qt_png_save(LiVESPixbuf *pixbuf, const char *fname, LiVESError **errptr, int cmp) {
4099 #ifdef IS_MINGW
4100 QImageWriter qiw(QString::fromUtf8(fname), "png");
4101 #else
4102 QImageWriter qiw(QString::fromLocal8Bit(fname), "png");
4103 #endif
4104 qiw.setCompression(cmp);
4105 if (!qiw.write(static_cast<QImage>(*pixbuf))) {
4106 if (errptr != NULL) {
4107 *errptr = (LiVESError *)malloc(sizeof(LiVESError));
4108 (*errptr)->code = qiw.error();
4109 (*errptr)->message = strdup(qiw.errorString().toUtf8().constData());
4110 }
4111 }
4112 }
4113
4114
4115
4116 // scrolledwindow policies
4117 typedef Qt::ScrollBarPolicy LiVESPolicyType;
4118 #define LIVES_POLICY_AUTOMATIC Qt::ScrollBarAsNeeded
4119 #define LIVES_POLICY_NEVER Qt::ScrollBarAlwaysOff
4120 #define LIVES_POLICY_ALWAYS Qt::ScrollBarAlwaysOn
4121
4122
4123 class LiVESFrame : public LiVESWidget, public QGroupBox {
4124 public:
LiVESFrame(QString text)4125 LiVESFrame(QString text) {
4126 set_type(LIVES_WIDGET_TYPE_FRAME);
4127
4128 LiVESWidget *label_widget = new LiVESLabel(text);
4129 set_label_widget(label_widget);
4130 }
4131
4132
set_label(QString text)4133 void set_label(QString text) {
4134 label_widget->set_text(text);
4135 }
4136
4137
set_label_widget(LiVESWidget * widget)4138 void set_label_widget(LiVESWidget *widget) {
4139 if (label_widget != NULL) {
4140 remove_child(static_cast<LiVESWidget *>(label_widget));
4141 }
4142 if (widget != NULL) {
4143 add_child(label_widget);
4144 label_widget = dynamic_cast<LiVESLabel *>(widget);
4145 label_widget->set_owner(this);
4146 setTitle(label_widget->text());
4147 } else {
4148 label_widget = NULL;
4149 setTitle(NULL);
4150 }
4151
4152 }
4153
get_label_widget()4154 LiVESWidget *get_label_widget() {
4155 return static_cast<LiVESWidget *>(label_widget);
4156 }
4157
4158
4159
get_layout()4160 LiVESWidget *get_layout() {
4161 if (layout == NULL) {
4162 layout = new LiVESVBox;
4163 (static_cast<QGroupBox *>(this))->setLayout(dynamic_cast<QLayout *>(layout));
4164 if ((static_cast<LiVESWidget *>(this))->isVisible()) layout->setVisible(true);
4165 add_child(layout);
4166 }
4167 return layout;
4168 }
4169
4170
4171 private:
4172 LiVESWidget *layout;
4173 LiVESLabel *label_widget;
4174
4175
4176 };
4177
4178
4179 class LiVESFileChooser : public LiVESWidget, public QFileDialog {
4180 public:
LiVESFileChooser()4181 LiVESFileChooser() {
4182 set_type(LIVES_WIDGET_TYPE_FILE_CHOOSER);
4183 }
4184
4185 };
4186
4187
4188 typedef int LiVESFileChooserAction;
4189 #define LIVES_FILE_CHOOSER_ACTION_OPEN 1
4190 #define LIVES_FILE_CHOOSER_ACTION_SAVE 2
4191 #define LIVES_FILE_CHOOSER_ACTION_SELECT_FOLDER 3
4192 #define LIVES_FILE_CHOOSER_ACTION_CREATE_FOLDER 4
4193 #define LIVES_FILE_CHOOSER_ACTION_SELECT_DEVICE 5
4194
4195
4196 class LiVESNotebook : public LiVESWidget, public QTabWidget {
4197 public:
4198
LiVESNotebook()4199 LiVESNotebook() {
4200 set_type(LIVES_WIDGET_TYPE_NOTEBOOK);
4201 }
4202
~LiVESNotebook()4203 ~LiVESNotebook() {
4204 for (int i = 0; i < label_widgets.size(); i++) {
4205 label_widgets[i]->dec_refcount();
4206 }
4207 }
4208
set_tab_label(LiVESWidget * child,LiVESWidget * xlabel)4209 void set_tab_label(LiVESWidget *child, LiVESWidget *xlabel) {
4210 int i = get_child_index(child);
4211 if (i == -1) return;
4212
4213 if (xlabel != NULL) {
4214 label_widgets[i]->dec_refcount();
4215 LiVESLabel *label = dynamic_cast<LiVESLabel *>(xlabel);
4216 label_widgets[i] = label;
4217 label->set_owner(this);
4218 QLabel *qlabel = static_cast<QLabel *>(label);
4219 setTabText(i, qlabel->text());
4220 }
4221 }
4222
4223
append_page()4224 void append_page() {
4225 LiVESWidget *label_widget = new LiVESLabel(NULL);
4226 label_widgets.append(label_widget);
4227 }
4228
4229 private:
4230 QList <LiVESWidget *> label_widgets;
4231
4232
4233 };
4234
4235
4236
4237 class LiVESToolbar : public LiVESWidget, public QToolBar {
4238 public:
4239
LiVESToolbar()4240 LiVESToolbar() {
4241 set_type(LIVES_WIDGET_TYPE_TOOLBAR);
4242 }
4243
add_action(QAction * act,int pos)4244 void add_action(QAction *act, int pos) {
4245 actions.insert(pos, act);
4246 }
4247
get_action(int pos)4248 QAction *get_action(int pos) {
4249 return actions.at(pos);
4250 }
4251
num_actions()4252 int num_actions() {
4253 return actions.size();
4254 }
4255
4256 private:
4257 QList<QAction *>actions;
4258
4259
4260 };
4261
4262
4263
4264 class LiVESColorButton : public LiVESButtonBase, public QPushButton {
4265 //Q_OBJECT
4266
4267 public:
4268
LiVESColorButton(const LiVESWidgetColor * col)4269 LiVESColorButton(const LiVESWidgetColor *col) {
4270 set_type(LIVES_WIDGET_TYPE_COLOR_BUTTON);
4271 static_cast<QObject *>(static_cast<QPushButton *>(this))->connect(static_cast<QObject *>(static_cast<QPushButton *>(this)),
4272 SIGNAL(clicked()),
4273 static_cast<QObject *>(static_cast<QPushButton *>(this)),
4274 SLOT(onClicked()));
4275
4276 use_alpha = FALSE;
4277 set_colour(col);
4278 }
4279
set_colour(const LiVESWidgetColor * col)4280 void set_colour(const LiVESWidgetColor *col) {
4281 QColor xcolor(col->red * 255., col->green * 255., col->blue * 255., col->alpha * 255.);
4282 set_colour(xcolor);
4283 }
4284
set_colour(QColor xcolour)4285 void set_colour(QColor xcolour) {
4286 if (colour != xcolour) {
4287 colour = xcolour;
4288 QPushButton *qpb = static_cast<QPushButton *>(this);
4289 QPalette p = qpb->palette();
4290 QColor mycolour = xcolour;
4291 if (!use_alpha) mycolour.setAlpha(255);
4292 p.setColor(QPalette::Button, mycolour);
4293 qpb->setPalette(p);
4294
4295 //Q_EMIT changed();
4296 }
4297 }
4298
4299
get_colour()4300 QColor get_colour() {
4301 return colour;
4302 }
4303
get_colour(LiVESWidgetColor * col)4304 void get_colour(LiVESWidgetColor *col) {
4305 col->red = (float)colour.red() / 255.;
4306 col->green = (float)colour.green() / 255.;
4307 col->blue = (float)colour.blue() / 255.;
4308 col->alpha = (float)colour.alpha() / 255.;
4309 }
4310
4311
set_title(const char * xtitle)4312 void set_title(const char *xtitle) {
4313 title = QString::fromUtf8(xtitle);
4314 }
4315
set_use_alpha(boolean val)4316 void set_use_alpha(boolean val) {
4317 use_alpha = val;
4318 }
4319
4320
4321 /* Q_SIGNALS:
4322 void changed();
4323
4324 private Q_SLOTS:
4325
4326 void onClicked() {
4327 QColor mycolour = colour;
4328 if (!use_alpha) mycolour.setAlpha(255);
4329 QColorDialog dlg(mycolour);
4330 dlg.setWindowTitle(title);
4331 dlg.setOption(QColorDialog::ShowAlphaChannel, use_alpha);
4332 if(dlg.exec() == QDialog::Accepted) {
4333 set_colour(dlg.selectedColor());
4334 }
4335 if (!use_alpha) colour.setAlpha(255);
4336 }*/
4337
4338 private:
4339 QColor colour;
4340 boolean use_alpha;
4341 QString title;
4342 };
4343
4344
4345
4346 class LiVESTimer : public LiVESWidgetObject, public QTimer {
4347 public:
4348
4349 LiVESTimer(uint32_t interval, LiVESWidgetSourceFunc xfunc, livespointer data);
4350
get_handle()4351 uint32_t get_handle() {
4352 return handle;
4353 }
4354
4355 /* public slots:*/
4356
4357 void update();
4358
4359
4360 private:
4361 uint32_t handle;
4362 LiVESWidgetSourceFunc func;
4363 livespointer data;
4364
4365 };
4366
4367 static QList<LiVESTimer *> static_timers;
4368
4369
LiVESTimer(uint32_t interval,LiVESWidgetSourceFunc xfunc,livespointer data)4370 LiVESTimer::LiVESTimer(uint32_t interval, LiVESWidgetSourceFunc xfunc, livespointer data) {
4371 set_type(LIVES_OBJECT_TYPE_TIMER);
4372 static_timers.append(this);
4373
4374 static_cast<QObject *>(static_cast<QTimer *>(this))->connect(static_cast<QObject *>(static_cast<QTimer *>(this)),
4375 SIGNAL(timeout()),
4376 static_cast<QObject *>(static_cast<QTimer *>(this)),
4377 SLOT(update()));
4378 start(interval);
4379
4380 }
4381
4382
update()4383 void LiVESTimer::update() {
4384 // ret false to stop
4385 boolean ret = (func)(data);
4386 if (!ret) {
4387 stop();
4388 static_timers.removeOne(this);
4389 }
4390 }
4391
4392
remove_static_timer(uint32_t handle)4393 void remove_static_timer(uint32_t handle) {
4394 for (int i = 0; i < static_timers.size(); i++) {
4395 if (static_timers.at(i)->get_handle() == handle) {
4396 static_timers.removeOne(static_timers.at(i));
4397 break;
4398 }
4399 }
4400 }
4401
4402
4403 typedef Qt::ToolButtonStyle LiVESToolbarStyle;
4404 #define LIVES_TOOLBAR_ICONS Qt::ToolButtonIconOnly
4405 #define LIVES_TOOLBAR_TEXT Qt::ToolButtonTextOnly
4406
4407 typedef QSize LiVESRequisition;
4408
4409 typedef int LiVESTextIter;
4410
4411 class LiVESTreePath {
4412 public:
4413
LiVESTreePath(const char * string)4414 LiVESTreePath(const char *string) {
4415 QString qs(string);
4416 QStringList qsl = qs.split(":");
4417 QList<int> qli;
4418
4419 for (int i = 0; i < qsl.size(); i++) {
4420 qli.append(qsl.at(i).toInt());
4421 }
4422
4423 init(qli);
4424 }
4425
LiVESTreePath(QList<int> qli)4426 LiVESTreePath(QList<int> qli) {
4427 init(qli);
4428 }
4429
~LiVESTreePath()4430 ~LiVESTreePath() {
4431 delete indices;
4432 }
4433
4434
get_depth()4435 int get_depth() {
4436 return cnt;
4437 }
4438
4439
get_indices()4440 int *get_indices() {
4441 return indices;
4442 }
4443
4444 private:
4445 int *indices;
4446 int cnt;
4447
init(QList<int> qli)4448 void init(QList<int> qli) {
4449 cnt = qli.size();
4450 indices = (int *)(malloc(cnt * sizeof(int)));
4451 for (int i = 0; i < cnt; i++) {
4452 indices[i] = qli.at(i);
4453 }
4454 }
4455
4456 };
4457
4458
4459 typedef Qt::Orientation LiVESOrientation;
4460 #define LIVES_ORIENTATION_HORIZONTAL Qt::Horizontal
4461 #define LIVES_ORIENTATION_VERTICAL Qt::Vertical
4462
4463 typedef int LiVESButtonBoxStyle;
4464 #define LIVES_BUTTONBOX_DEFAULT_STYLE 0
4465 #define LIVES_BUTTONBOX_SPREAD 1
4466 #define LIVES_BUTTONBOX_EDGE 2
4467 #define LIVES_BUTTONBOX_START 3
4468 #define LIVES_BUTTONBOX_END 4
4469 #define LIVES_BUTTONBOX_CENTER 5
4470
4471 typedef int LiVESReliefStyle;
4472
4473 #define LIVES_RELIEF_NORMAL 2
4474 #define LIVES_RELIEF_HALF 1
4475 #define LIVES_RELIEF_NONE 0
4476
4477 #define LIVES_ACCEL_VISIBLE 1
4478
4479 typedef int LiVESWindowType;
4480 #define LIVES_WINDOW_TOPLEVEL Qt::Window
4481 #define LIVES_WINDOW_POPUP Qt::Popup
4482
4483 typedef QFrame::Shadow LiVESShadowType;
4484 #define LIVES_SHADOW_NONE QFrame::Plain
4485 #define LIVES_SHADOW_IN QFrame::Raised
4486 #define LIVES_SHADOW_OUT QFrame::Sunken
4487 #define LIVES_SHADOW_ETCHED_IN QFrame::Raised
4488 #define LIVES_SHADOW_ETCHED_OUT QFrame::Sunken
4489
4490
4491
4492 typedef int LiVESPositionType;
4493 #define LIVES_POS_LEFT 1
4494 #define LIVES_POS_RIGHT 2
4495 #define LIVES_POS_TOP 3
4496 #define LIVES_POS_BOTTOM 4
4497
4498
4499 #define LIVES_WIDGET(a) ((LiVESWidget *)a)
4500
4501
4502 #define LIVES_EDITABLE(a) (a)
4503
4504 #define LIVES_CONTAINER(a) LIVES_WIDGET(a)
4505 #define LIVES_GUI_OBJECT(a) LIVES_WIDGET(a)
4506 #define LIVES_EXPANDER(a) LIVES_WIDGET(a)
4507 #define LIVES_BIN(a) LIVES_WIDGET(a)
4508 #define LIVES_MENU_SHELL(a) LIVES_WIDGET(a)
4509
4510 #define LIVES_WIDGET_OBJECT(a) ((LiVESWidgetObject *)a)
4511 #define LIVES_COMBO(a) ((LiVESCombo *)a)
4512 #define LIVES_HBOX(a) ((LiVESHBox *)a)
4513 #define LIVES_VBOX(a) ((LiVESVBox *)a)
4514 #define LIVES_BOX(a) ((LiVESBox *)a)
4515 #define LIVES_ALIGNMENT(a) ((LiVESAlignment *)a)
4516 #define LIVES_TOOLBAR(a) ((LiVESToolbar *)a)
4517 #define LIVES_TOOL_BUTTON(a) ((LiVESToolButton *)a)
4518 #define LIVES_EVENT_BOX(a) ((LiVESEventBox *)a)
4519 #define LIVES_DRAWING_AREA(a) ((LiVESDrawingArea *)a)
4520 #define LIVES_TEXT_VIEW(a) ((LiVESTextView *)a)
4521 #define LIVES_TEXT_BUFFER(a) ((LiVESTextBuffer *)a)
4522 #define LIVES_BUTTON_BOX(a) ((LiVESButtonBox *)a)
4523 #define LIVES_FRAME(a) ((LiVESFrame *)a)
4524 #define LIVES_SCALE(a) ((LiVESScale *)a)
4525 #define LIVES_RANGE(a) ((LiVESRange *)a)
4526 #define LIVES_ADJUSTMENT(a) ((LiVESAdjustment *)a)
4527 #define LIVES_TABLE(a) ((LiVESTable *)a)
4528 #define LIVES_NOTEBOOK(a) ((LiVESNotebook *)a)
4529 #define LIVES_MENU(a) ((LiVESMenu *)a)
4530 #define LIVES_MENU_ITEM(a) ((LiVESMenuItem *)a)
4531 #define LIVES_MENU_TOOL_ITEM(a) ((LiVESMenuToolItem *)a)
4532 #define LIVES_MENU_TOOL_BUTTON(a) ((LiVESMenuToolButton *)a)
4533 #define LIVES_RULER(a) ((LiVESRuler *)a)
4534 #define LIVES_CHECK_MENU_ITEM(a) ((LiVESCheckMenuItem *)a)
4535 #define LIVES_IMAGE(a) ((LiVESImage *)a)
4536 #define LIVES_PROGRESS_BAR(a) ((LiVESProgressBar *)a)
4537 #define LIVES_BUTTON(a) ((LiVESButton *)a)
4538 #define LIVES_SPIN_BUTTON(a) ((LiVESSpinButton *)a)
4539 #define LIVES_SCALE_BUTTON(a) ((LiVESScaleButton *)a)
4540 #define LIVES_TOGGLE_BUTTON(a) ((LiVESToggleButton *)a)
4541 #define LIVES_RADIO_BUTTON(a) ((LiVESRadioButton *)a)
4542 #define LIVES_RADIO_MENU_ITEM(a) ((LiVESRadioMenuItem *)a)
4543 #define LIVES_COLOR_BUTTON(a) ((LiVESColorButton *)a)
4544 #define LIVES_DIALOG(a) ((LiVESDialog *)a)
4545 #define LIVES_LABEL(a) ((LiVESLabel *)a)
4546 #define LIVES_ENTRY(a) ((LiVESEntry *)a)
4547 #define LIVES_PANED(a) ((LiVESPaned *)a)
4548 #define LIVES_FILE_CHOOSER(a) ((LiVESFileChooser *)a)
4549 #define LIVES_ACCEL_GROUP(a) ((LiVESAccelGroup *)a)
4550 #define LIVES_WINDOW(a) ((LiVESWindow *)a)
4551 #define LIVES_SCROLLED_WINDOW(a) ((LiVESScrolledWindow *)a)
4552 #define LIVES_TREE_MODEL(a) ((LiVESTreeModel *)a)
4553 #define LIVES_TREE_VIEW(a) ((LiVESTreeView *)a)
4554 #define LIVES_LIST_STORE(a) ((LiVESListStore *)a)
4555 #define LIVES_TOOL_ITEM(a) ((LiVESToolItem *)a)
4556
4557
4558 #define LIVES_STOCK_UNDO "edit-undo"
4559 #define LIVES_STOCK_REDO "edit-redo"
4560 #define LIVES_STOCK_ADD "list-add"
4561 #define LIVES_STOCK_REMOVE "list-remove"
4562 #define LIVES_STOCK_NO "media-record"
4563 #define LIVES_STOCK_QUIT "application-exit"
4564 #define LIVES_STOCK_OPEN "document-open"
4565 #define LIVES_STOCK_CLOSE "window-close"
4566 #define LIVES_STOCK_CLEAR "edit-clear"
4567 #define LIVES_STOCK_DELETE "edit-delete"
4568 #define LIVES_STOCK_SAVE_AS "document-save-as"
4569 #define LIVES_STOCK_SAVE "document-save"
4570 #define LIVES_STOCK_REFRESH "view-refresh"
4571 #define LIVES_STOCK_REVERT_TO_SAVED "document-revert"
4572 #define LIVES_STOCK_GO_BACK "go-previous"
4573 #define LIVES_STOCK_GO_FORWARD "go-next"
4574 #define LIVES_STOCK_REFRESH "view-refresh"
4575 #define LIVES_STOCK_MEDIA_PLAY "media-playback-start"
4576 #define LIVES_STOCK_MEDIA_STOP "media-playback-stop"
4577 #define LIVES_STOCK_MEDIA_REWIND "media-seek-backward"
4578 #define LIVES_STOCK_MEDIA_RECORD "media-record"
4579 #define LIVES_STOCK_MEDIA_PAUSE "media-pause"
4580 #define LIVES_STOCK_PREFERENCES "preferences-system"
4581 #define LIVES_STOCK_DIALOG_INFO "dialog-information"
4582 #define LIVES_STOCK_MISSING_IMAGE "image-missing"
4583
4584
4585 #define LIVES_STOCK_YES "gtk-yes" // non-standard image ?
4586 #define LIVES_STOCK_APPLY "gtk-apply" // non-standard image ?
4587 #define LIVES_STOCK_CANCEL "gtk-cancel" // non-standard image ?
4588 #define LIVES_STOCK_OK "gtk-ok" // non-standard image ?
4589
4590
4591 char LIVES_STOCK_LABEL_CANCEL[32];
4592 char LIVES_STOCK_LABEL_OK[32];
4593 char LIVES_STOCK_LABEL_YES[32];
4594 char LIVES_STOCK_LABEL_NO[32];
4595 char LIVES_STOCK_LABEL_SAVE[32];
4596 char LIVES_STOCK_LABEL_SAVE_AS[32];
4597 char LIVES_STOCK_LABEL_OPEN[32];
4598 char LIVES_STOCK_LABEL_QUIT[32];
4599 char LIVES_STOCK_LABEL_APPLY[32];
4600 char LIVES_STOCK_LABEL_CLOSE[32];
4601 char LIVES_STOCK_LABEL_REVERT[32];
4602 char LIVES_STOCK_LABEL_REFRESH[32];
4603 char LIVES_STOCK_LABEL_DELETE[32];
4604 char LIVES_STOCK_LABEL_GO_FORWARD[32];
4605
4606
4607 typedef int LiVESAttachOptions;
4608 #define LIVES_EXPAND 1
4609 #define LIVES_SHRINK 2
4610 #define LIVES_FILL 3
4611
4612
4613 //typedef int LiVESWrapMode;
4614 //#define LIVES_WRAP_NONE QTextEdit::NoWrap
4615 //#define LIVES_WRAP_WORD QTextEdit::WidgetWidth
4616
4617 typedef bool LiVESWrapMode;
4618 #define LIVES_WRAP_NONE false
4619 #define LIVES_WRAP_WORD true
4620
4621 typedef Qt::Alignment LiVESJustification;
4622
4623 #define LIVES_JUSTIFY_LEFT Qt::AlignLeft
4624 #define LIVES_JUSTIFY_RIGHT Qt::AlignRight
4625 #define LIVES_JUSTIFY_CENTER Qt::AlignHCenter
4626 #define LIVES_JUSTIFY_FILL Qt::AlignJustify
4627
4628 extern "C" {
4629 boolean lives_container_remove(LiVESContainer *, LiVESWidget *);
4630 }
4631
4632
~LiVESWidget()4633 LiVESWidget::~LiVESWidget() {
4634 if (LIVES_IS_SPIN_BUTTON(this)) {
4635 LiVESAdjustment *adj = (static_cast<LiVESSpinButton *>(this))->get_adj();
4636 adj->dec_refcount();
4637 }
4638
4639 if (LIVES_IS_RANGE(this)) {
4640 LiVESAdjustment *adj = (dynamic_cast<LiVESRange *>(this))->get_adj();
4641 adj->dec_refcount();
4642 }
4643
4644 if (LIVES_IS_TREE_VIEW(this)) {
4645 LiVESAdjustment *adj = (static_cast<LiVESTreeView *>(this))->get_hadj();
4646 adj->dec_refcount();
4647 adj = (static_cast<LiVESTreeView *>(this))->get_vadj();
4648 adj->dec_refcount();
4649 }
4650
4651 if (LIVES_IS_SCROLLED_WINDOW(this)) {
4652 LiVESAdjustment *adj = (static_cast<LiVESScrolledWindow *>(this))->get_hadj();
4653 adj->dec_refcount();
4654 adj = (static_cast<LiVESScrolledWindow *>(this))->get_vadj();
4655 adj->dec_refcount();
4656 }
4657
4658 // remove from parents children
4659 if (parent != NULL) {
4660 inc_refcount();
4661 parent->remove_child(this);
4662 }
4663
4664 LiVESList *xchildren = children;
4665
4666 // decref all children
4667 while (xchildren != NULL) {
4668 lives_container_remove(this, (LiVESWidget *)xchildren->data);
4669 xchildren = xchildren->next;
4670 }
4671
4672 lives_list_free(children);
4673 }
4674
4675 #define LINGO_ALIGN_LEFT Qt::AlignLeft
4676 #define LINGO_ALIGN_RIGHT Qt::AlignRight
4677 #define LINGO_ALIGN_CENTER Qt::AlignHCenter
4678
4679 #define LINGO_SCALE 1
4680
4681 typedef class lives_painter_t lives_painter_t;
4682
4683 class LingoLayout : public LiVESWidgetObject {
4684 public:
LingoLayout(const char * xtext,const char * xfont,double fsize)4685 LingoLayout(const char *xtext, const char *xfont, double fsize) {
4686 text = QString::fromUtf8(xtext);
4687 font = QFont(QString::fromUtf8(xfont));
4688 font.setPointSizeF((float)fsize);
4689 align = LINGO_ALIGN_LEFT;
4690 }
4691
set_alignment(int xalign)4692 void set_alignment(int xalign) {
4693 align = xalign;
4694 }
4695
set_text(const char * xtext,ssize_t len)4696 void set_text(const char *xtext, ssize_t len) {
4697 text = QString::fromUtf8(xtext, len);
4698 }
4699
4700 void get_size(int *bwidth, int *bheight, int pwidth, int pheight);
4701
set_coords(int xx,int xy,int xwidth,int xheight)4702 void set_coords(int xx, int xy, int xwidth, int xheight) {
4703 x = xx;
4704 y = xy;
4705 width = xwidth;
4706 height = xheight;
4707 }
4708
4709 void render_text(lives_painter_t *painter);
4710
4711
4712 private:
4713 QString text;
4714 QFont font;
4715 int align;
4716 int x, y, width, height;
4717 };
4718
lingo_layout_set_alignment(LingoLayout * l,int alignment)4719 LIVES_INLINE void lingo_layout_set_alignment(LingoLayout *l, int alignment) {
4720 l->set_alignment(alignment);
4721 }
4722
4723
lingo_layout_set_text(LingoLayout * l,const char * text,ssize_t len)4724 LIVES_INLINE void lingo_layout_set_text(LingoLayout *l, const char *text, ssize_t len) {
4725 l->set_text(text, len);
4726 }
4727
4728
lingo_layout_set_coords(LingoLayout * l,int x,int y,int width,int height)4729 LIVES_INLINE void lingo_layout_set_coords(LingoLayout *l, int x, int y, int width, int height) {
4730 l->set_coords(x, y, width, height);
4731 }
4732
4733
lingo_layout_get_size(LingoLayout * l,int * rw,int * rh,int width,int height)4734 LIVES_INLINE void lingo_layout_get_size(LingoLayout *l, int *rw, int *rh, int width, int height) {
4735 l->get_size(rw, rh, width, height);
4736 }
4737
4738
lingo_painter_show_layout(lives_painter_t * painter,LingoLayout * l)4739 LIVES_INLINE void lingo_painter_show_layout(lives_painter_t *painter, LingoLayout *l) {
4740 l->render_text(painter);
4741 }
4742
4743 #endif
4744
4745
4746
4747 #ifdef PAINTER_QPAINTER
4748 # include <QtGui/QPainter>
4749
4750 //extern void lives_free(livespointer ptr);
4751
imclean(livespointer data)4752 static void imclean(livespointer data) {
4753 lives_free(data);
4754 }
4755
4756 typedef QImage::Format lives_painter_format_t;
4757 #define LIVES_PAINTER_FORMAT_A1 QImage::Format_Mono
4758 #define LIVES_PAINTER_FORMAT_A8 QImage::Format_Indexed8
4759 #define LIVES_PAINTER_FORMAT_ARGB32 QImage::Format_ARGB32_Premultiplied
4760
4761
4762 class lives_painter_surface_t : public QImage, public LiVESWidgetObject {
4763 public:
4764 int refcount;
4765
lives_painter_surface_t(int width,int height,QImage::Format fmt)4766 lives_painter_surface_t(int width, int height, QImage::Format fmt) : QImage(width, height, fmt) {
4767 refcount = 0;
4768 }
4769
lives_painter_surface_t(uint8_t * data,lives_painter_format_t fmt,int width,int height,int stride)4770 lives_painter_surface_t (uint8_t *data, lives_painter_format_t fmt, int width, int height, int stride)
4771 : QImage(data, width, height, stride, fmt, imclean, (livespointer)data) {
4772 refcount = 0;
4773 }
4774
4775 };
4776
4777
4778 boolean lives_painter_surface_destroy(lives_painter_surface_t *);
4779
4780
4781 class lives_painter_t : public QPainter {
4782 public:
4783 QPainterPath *p;
4784 lives_painter_surface_t *target;
4785 QPen pen;
4786
4787
lives_painter_t(QWidget * widget)4788 lives_painter_t(QWidget *widget) : QPainter(widget) {
4789 init();
4790 };
4791
4792
lives_painter_t(lives_painter_surface_t * surf)4793 lives_painter_t(lives_painter_surface_t *surf) : QPainter() {
4794 init();
4795 target = surf;
4796 };
4797
4798
~lives_painter_t()4799 ~lives_painter_t() {
4800 if (target != NULL) lives_painter_surface_destroy(target);
4801 delete p;
4802 }
4803
4804
4805 private:
4806
init(void)4807 void init(void) {
4808 p = new QPainterPath();
4809 pen = QPen();
4810 target = NULL;
4811 }
4812
4813
4814 };
4815
4816
4817 #define LIVES_PAINTER_CONTENT_COLOR 0
4818
4819 typedef QPainter::CompositionMode lives_painter_operator_t;
4820
4821 #define LIVES_PAINTER_OPERATOR_UNKNOWN QPainter::CompositionMode_SourceOver
4822 #define LIVES_PAINTER_OPERATOR_DEFAULT QPainter::CompositionMode_SourceOver
4823
4824 #define LIVES_PAINTER_OPERATOR_DEST_OUT QPainter::CompositionMode_DestinationOut
4825
4826 #define LIVES_PAINTER_OPERATOR_DIFFERENCE QPainter::CompositionMode_Difference
4827 #define LIVES_PAINTER_OPERATOR_OVERLAY QPainter::CompositionMode_Overlay
4828
4829 typedef Qt::FillRule lives_painter_fill_rule_t;
4830
4831 #define LIVES_PAINTER_FILL_RULE_WINDING Qt::WindingFill
4832 #define LIVES_PAINTER_FILL_RULE_EVEN_ODD Qt::OddEvenFill
4833
4834
4835 #ifdef GUI_QT
4836
get_size(int * bwidth,int * bheight,int pwidth,int pheight)4837 void LingoLayout::get_size(int *bwidth, int *bheight, int pwidth, int pheight) {
4838 QPainter qp;
4839 QRect rect = qp.boundingRect(0, 0, pwidth, pheight, Qt::AlignLeft | Qt::AlignTop, text);
4840 *bwidth = rect.width();
4841 *bheight = rect.height();
4842 }
4843
4844
render_text(lives_painter_t * painter)4845 void LingoLayout::render_text(lives_painter_t *painter) {
4846 painter->drawText(x, y, width, height, align, text);
4847 }
4848
4849 #endif
4850
4851
4852 #endif
4853
4854 #include "moc_widget-helper-qt.cpp"
4855
4856
4857 #endif
4858