LiVES 3.2.0
widget-helper-qt.h
Go to the documentation of this file.
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
24using 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
97QApplication *qapp;
98QTime *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
119typedef void *livespointer;
120typedef 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
126LIVES_INLINE livespointer lives_int_to_pointer(int32_t a) {
127 return (livespointer)a;
128}
129
130LIVES_INLINE livespointer lives_uint_to_pointer(uint32_t a) {
131 return (livespointer)a;
132}
133
134LIVES_INLINE int32_t lives_pointer_to_int(livesconstpointer p) {
135 uint64_t xint = (uint64_t)p;
136 return (int32_t)(xint & 0xFFFF);
137}
138
139typedef 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
152LiVESMemVTable *static_alt_vtable;
153
154void (*lives_free)(livespointer ptr);
155livespointer(*lives_malloc)(size_t size);
156livespointer(*lives_realloc)(livespointer ptr, size_t new_size);
157livespointer(*lives_try_malloc)(size_t size);
158livespointer(*lives_try_realloc)(livespointer ptr, size_t new_size);
159livespointer(_lives_calloc)(size_t n_blocks, size_t n_block_bytes);
160
161
162livespointer malloc_wrapper(size_t size) {
163 livespointer ptr = (static_alt_vtable->malloc)(size);
164 Q_ASSERT(ptr != NULL);
165 return ptr;
166}
167
168
169livespointer 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
176livespointer try_malloc_wrapper(size_t size) {
177 return (static_alt_vtable->malloc)(size);
178}
179
180
181livespointer try_realloc_wrapper(livespointer old_ptr, size_t new_size) {
182 return (static_alt_vtable->realloc)(old_ptr, new_size);
183}
184
185
186LIVES_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
193LIVES_INLINE livespointer lives_try_malloc0(size_t size) {
194 return (static_alt_vtable->calloc)(1, size);
195}
196
197
198LIVES_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
207extern char *trString;
208
209// TODO - move to support.c
210char *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
219char *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
229int 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
245char *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
255int 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
264void 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
275int 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
290int 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
307char *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
338char *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
378char *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
386char *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;
403next:
404 p--;
405 }
406 return NULL;
407}
408
409
410
411LIVES_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
421LIVES_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
431char *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
440char *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
450char *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
461char *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
473typedef bool boolean;
474#endif
475
476
477typedef boolean(*LiVESWidgetSourceFunc)(livespointer data);
478
479typedef 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
490extern "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
497LIVES_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
502LIVES_INLINE uint32_t lives_idle_add(LiVESWidgetSourceFunc function, livespointer data) {
503 return lives_timer_add(0, function, data);
504}
505
507#define g_object_freeze_notify(a) (a)
508#define g_object_thaw_notify(a) (a)
509
510
511LIVES_INLINE void lives_set_application_name(const char *name) {
512 qapp->setApplicationName(QString::fromUtf8(name));
513}
514
515
516LIVES_INLINE const char *lives_get_application_name() {
517 return qapp->applicationName().toLocal8Bit().constData();
518}
519
520
521class SleeperThread : public QThread {
522public:
523 static void msleep(unsigned long msecs) {
524 QThread::msleep(msecs);
525 }
526};
527
528LIVES_INLINE void lives_usleep(ulong microsec) {
529 SleeperThread::msleep(microsec);
530}
531
532
533LIVES_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
549char *lives_path_get_basename(const char *path) {
550 QFileInfo qf(path);
551 QString qs = qf.fileName();
552 return strdup(qs.toUtf8().constData());
553}
554
555char *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
563typedef 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
569boolean 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
584char *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
594typedef struct {
595 ulong function;
596 livespointer data;
597} LiVESClosure;
598
599typedef LiVESClosure LiVESWidgetClosure;
600
601
602
604
605
606typedef void (*LiVESPixbufDestroyNotify)(uchar *, livespointer);
607
608
609typedef int lives_painter_content_t;
610
611
612
613typedef struct {
614 int code;
615 char *message;
616} LiVESError;
617
618
619LIVES_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
627typedef QScreen LiVESXScreen;
628typedef QScreen LiVESXDisplay;
629typedef QScreen LiVESXDevice;
630
631#ifndef HAVE_X11
632typedef WId Window;
633#endif
634
635typedef QFile LiVESIOChannel;
636
637
638
639//#define LIVES_TABLE_IS_GRID 1 // no "remove row" available
640
641
642
643typedef 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)
659#define LIVES_WIDGET_COLOR_SCALE_255(x) ((double)x/255.)
660
661
662typedef 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
742typedef int LiVESAccelFlags;
743
744typedef class LiVESAccelGroup LiVESAccelGroup;
745typedef class LiVESWidget LiVESWidget;
746
747
748typedef void LiVESXEvent;
749typedef void LiVESXXEvent;
750typedef void LiVESXEventMotion;
751typedef void LiVESXEventFocus;
752
753typedef QCursor LiVESXCursor;
754
755
756#define LIVES_SCROLL_UP 1
757#define LIVES_SCROLL_DOWN 2
758
759typedef struct {
760 int direction;
761 LiVESXModifierType state;
762} LiVESXEventScroll;
763
764
765typedef struct {
766 int x;
767 int y;
768 int width;
769 int height;
770} LiVESRect;
771
772
773typedef struct {
774 int count;
775 LiVESRect area;
776} LiVESXEventExpose;
777
778
779typedef 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
790typedef void LiVESXEventCrossing;
791typedef void LiVESXEventConfigure;
792typedef void LiVESXEventDelete;
793
794
795typedef class LiVESWidgetObject LiVESWidgetObject;
796
797typedef void (*LiVESWidgetCallback)(LiVESWidget *widget, livespointer data);
798
799LiVESClosure *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
808typedef boolean(*LiVESScrollEventCallback)(LiVESWidget *widget, LiVESXEventScroll *, livespointer data);
809typedef boolean(*LiVESExposeEventCallback)(LiVESWidget *widget, LiVESXEventExpose *, livespointer data);
810typedef boolean(*LiVESEnterEventCallback)(LiVESWidget *widget, LiVESXEventCrossing *, livespointer data);
811typedef boolean(*LiVESButtonEventCallback)(LiVESWidget *widget, LiVESXEventButton *, livespointer data);
812typedef boolean(*LiVESConfigureEventCallback)(LiVESWidget *widget, LiVESXEventConfigure *, livespointer data);
813typedef boolean(*LiVESDeleteEventCallback)(LiVESWidget *widget, LiVESXEventDelete *, livespointer data);
814typedef 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
820typedef void LiVESTargetEntry;
821
822typedef bool LiVESFilterReturn;
823
824#define LIVES_FILTER_REMOVE true
825#define LIVES_FILTER_CONTINUE false
826
827
828typedef 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
844typedef struct {
845 // values from 0.0 -> 1.0
846 double red;
847 double green;
848 double blue;
849 double alpha;
850} LiVESWidgetColor;
851
852
853boolean return_true() {
854 return TRUE;
855}
856
857
858typedef 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
908extern "C" {
909 LiVESWidgetColor *lives_widget_color_copy(LiVESWidgetColor *c1orNULL, const LiVESWidgetColor *c2);
910}
911
912static 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
922typedef 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
971LIVES_INLINE QKeySequence make_qkey_sequence(uint32_t key, LiVESXModifierType mods) {
972 return static_cast<Qt::Key>(key) | mods;
973}
974
975LIVES_INLINE uint32_t qkeysequence_get_key(QKeySequence ks) {
976 return ks[0] & 0x01FFFFFF;
977}
978
979
980LIVES_INLINE LiVESXModifierType qkeysequence_get_mod(QKeySequence ks) {
981 return static_cast<LiVESXModifierType>(ks[0] & 0xF2000000);
982}
983
984
985class evFilter : public QObject {
986public:
987
988protected:
989 bool eventFilter(QObject *obj, QEvent *event);
990
991};
992
993
994#ifdef HAVE_X11
995
996class nevfilter : public QAbstractNativeEventFilter {
997public:
998
999 virtual bool nativeEventFilter(const QByteArray &eventType, livespointer message, long *);
1000
1001};
1002
1003#endif
1004
1005class LiVESWidgetObject : public QWidget {
1006 Q_OBJECT
1007
1008public:
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
1040 LiVESWidgetObject() {
1041 init();
1042 };
1043
1044
1045 LiVESWidgetObject(const LiVESWidgetObject &xobj) {
1046 init();
1047 type = xobj.type;
1048 }
1049
1050 void ref_sink() {
1051 if (floating) floating = false;
1052 else inc_refcount();
1053 }
1054
1055 void inc_refcount() {
1056 refcount++;
1057 }
1058
1059 void dec_refcount() {
1060 if (--refcount == 0) {
1061 finalise();
1062 }
1063 }
1064
1065 void no_refcount() {
1066 refcount = 0;
1067 }
1068
1069
1070 void set_type(LiVESWidgetObjectType xtype) {
1071 type = xtype;
1072 }
1073
1074 LiVESWidgetObjectType get_type() {
1075 return type;
1076 }
1077
1078private:
1079 bool floating;
1080 int refcount;
1081 evFilter *eFilter;
1082 QList<LiVESAccel *>accels;
1083 QList<LiVESAccelGroup *>accel_groups;
1084 LiVESWidgetObjectType type;
1085
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
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
1107typedef struct LiVESList LiVESList;
1108
1109struct LiVESList {
1110 livesconstpointer data;
1111 LiVESList *prev;
1112 LiVESList *next;
1113};
1114
1115
1116typedef struct LiVESSList LiVESSList;
1117
1118struct LiVESSList {
1119 livesconstpointer data;
1120 LiVESSList *next;
1121};
1122
1123typedef LiVESList LiVESDList;
1124
1125
1126LIVES_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
1133LIVES_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
1138LIVES_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
1145LIVES_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
1151LIVES_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
1159LIVES_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
1173LIVES_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
1186LIVES_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
1204LIVES_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
1222LIVES_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
1239LIVES_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
1248LIVES_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
1256LIVES_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
1281LIVES_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
1290LIVES_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
1301LIVES_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
1311LIVES_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
1321LIVES_INLINE LiVESList *lives_list_previous(LiVESList *list) {
1322 if (list == NULL) return NULL;
1323 return list->prev;
1324}
1325
1326
1327LIVES_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
1335LIVES_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
1342LIVES_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
1352LIVES_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
1361char **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
1396char *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
1408char *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;
1426next:
1427 p++;
1428 }
1429 return NULL;
1430 }
1431}
1432
1433
1434
1435#define ICON_SCALE(a) ((int)(1.0 * a))
1436typedef 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
1446typedef 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
1451typedef 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
1468typedef 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
1475class LiVESWidget : public LiVESWidgetObject {
1476 Q_OBJECT
1477
1478public:
1479
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
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
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
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
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
1544 void remove_child(LiVESWidget *child) {
1545 children = lives_list_remove(children, child);
1546 child->set_parent(NULL);
1547 child->dec_refcount();
1548 }
1549
1550 void set_parent(LiVESWidget *new_parent) {
1551 parent = new_parent;
1552 }
1553
1554 LiVESWidget *get_parent() {
1555 return parent;
1556 }
1557
1558 QString get_name() {
1559 return widgetName;
1560 }
1561
1562 void set_events(uint32_t mask) {
1563 events_mask = mask;
1564 }
1565
1566 void add_onetime_event_block(uint32_t mask) {
1567 onetime_events_mask |= mask;
1568 }
1569
1570 void remove_onetime_event_block(uint32_t mask) {
1571 if (onetime_events_mask & mask) onetime_events_mask ^= mask;
1572 }
1573
1574 uint32_t get_onetime_events_block() {
1575 return onetime_events_mask;
1576 }
1577
1578 uint32_t get_events() {
1579 return events_mask;
1580 }
1581
1582 int count_children() {
1583 return lives_list_length(children);
1584 }
1585
1586 LiVESList *get_children() {
1587 return children;
1588 }
1589
1590 void set_children(LiVESList *xchildren) {
1591 lives_list_free(children);
1592 children = xchildren;
1593 }
1594
1595 LiVESWidget *get_child(int index) {
1596 return (LiVESWidget *)lives_list_nth_data(children, index);
1597 }
1598
1599
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
1609 LiVESWidgetState get_state() {
1610 return state;
1611 }
1612
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
1632public slots:
1633 void cb_wrapper_clicked() {
1634 // "clicked" callback
1635 call_accels_for(LIVES_WIDGET_CLICKED_EVENT);
1636 }
1637
1638 void cb_wrapper_toggled() {
1639 // "toggled" callback
1640 call_accels_for(LIVES_WIDGET_CLICKED_EVENT);
1641 }
1642
1643
1644 void cb_wrapper_changed() {
1645 // "changed" callback
1646 call_accels_for(LIVES_WIDGET_CHANGED_EVENT);
1647 }
1648
1649
1650 void cb_wrapper_value_changed() {
1651 // "value-changed" callback
1652 call_accels_for(LIVES_WIDGET_VALUE_CHANGED_EVENT);
1653 }
1654
1655 void cb_wrapper_selection_changed() {
1656 // "selection-changed" callback
1657 call_accels_for(LIVES_WIDGET_SELECTION_CHANGED_EVENT);
1658 }
1659
1660 void cb_wrapper_current_folder_changed() {
1661 // "selection-changed" callback
1662 call_accels_for(LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT);
1663 }
1664
1665 void cb_wrapper_activate() {
1666 // "activate" callback
1667 call_accels_for(LIVES_WIDGET_ACTIVATE_EVENT);
1668 }
1669
1670 void cb_wrapper_response() {
1671 // "response" callback
1672 call_accels_for(LIVES_WIDGET_RESPONSE_EVENT);
1673 }
1674
1675private:
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
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
1743bool 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
1924void 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
1977void 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
2001void 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
2025void 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
2049void 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
2073LiVESWidgetColor *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
2097LiVESWidgetColor *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
2121ulong 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
2203LIVES_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
2209LIVES_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
2221void 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
2229void 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
2241void 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
2254boolean 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
2272boolean LiVESWidgetObject::activate_accel(uint32_t key, LiVESXModifierType mod) {
2273 return activate_accel(make_qkey_sequence(key, mod));
2274}
2275
2276
2277boolean 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
2307void 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
2315QList<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
2325QList<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
2334LiVESAccel *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
2344void LiVESWidgetObject::block_signal(ulong handler_id) {
2345 LiVESAccel *accel = get_accel_for(handler_id);
2346 accel->blocked = true;
2347}
2348
2349
2350void 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
2357void 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
2365void LiVESWidgetObject::unblock_signal(ulong handler_id) {
2366 LiVESAccel *accel = get_accel_for(handler_id);
2367 accel->blocked = false;
2368}
2369
2370
2371void 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
2379void 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
2387void LiVESWidgetObject::disconnect_signal(ulong handler_id) {
2388 LiVESAccel *accel = get_accel_for(handler_id);
2389 remove_accel(accel);
2390}
2391
2392
2393QList<LiVESAccelGroup *> LiVESWidgetObject::get_accel_groups() {
2394 return accel_groups;
2395}
2396
2397
2398
2399class LiVESBox : public LiVESWidget {};
2400
2401
2402class LiVESHBox : public LiVESBox, public QHBoxLayout {
2403public:
2404 LiVESHBox() {
2405 set_type(LIVES_WIDGET_TYPE_HBOX);
2406 }
2407};
2408
2409
2410class LiVESEventBox : public LiVESBox, public QHBoxLayout {
2411public:
2412 LiVESEventBox() {
2413 set_type(LIVES_WIDGET_TYPE_EVENT_BOX);
2414 }
2415};
2416
2417
2418class LiVESDrawingArea : public LiVESBox, public QHBoxLayout {
2419public:
2420 LiVESDrawingArea() {
2421 set_type(LIVES_WIDGET_TYPE_DRAWING_AREA);
2422 }
2423};
2424
2425
2426class LiVESVBox : public LiVESBox, public QVBoxLayout {
2427public:
2428 LiVESVBox() {
2429 set_type(LIVES_WIDGET_TYPE_VBOX);
2430 }
2431};
2432
2433
2434typedef class LiVESRange LiVESRange;
2435
2436class LiVESAdjustment : public LiVESWidgetObject {
2437
2438public:
2439
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
2451 void set_owner(LiVESWidget *widget) {
2452 owner = widget;
2453 }
2454
2455 LiVESWidget *get_owner() {
2456 return owner;
2457 }
2458
2459
2460 double get_value() {
2461 return value;
2462 }
2463
2464
2465 double get_upper() {
2466 return upper;
2467 }
2468
2469
2470 double get_lower() {
2471 return lower;
2472 }
2473
2474 double get_step_increment() {
2475 return step_increment;
2476 }
2477
2478 double get_page_increment() {
2479 return page_increment;
2480 }
2481
2482 double get_page_size() {
2483 return page_size;
2484 }
2485
2486 void freeze() {
2487 frozen = true;
2488 }
2489
2490 void thaw() {
2491 frozen = false;
2492 }
2493
2494private:
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
2508LIVES_INLINE QString qmake_mnemonic(QString qlabel) {
2509 qlabel = qlabel.replace('&', "&&");
2510 qlabel = qlabel.replace('_', '&');
2511 return qlabel;
2512}
2513
2514
2515LIVES_INLINE QString qmake_underline(QString qlabel) {
2516 qlabel = qlabel.replace('&', '_');
2517 qlabel = qlabel.replace("__", "&");
2518 return qlabel;
2519}
2520
2521
2522class LiVESButtonBase : public LiVESWidget {
2523public:
2524 LiVESButtonBase() {
2525 init();
2526 }
2527
2528 LiVESButtonBase(QString qs) {
2529 init();
2530 }
2531
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
2545 bool get_use_underline() {
2546 return use_underline;
2547 }
2548
2549private:
2550 bool use_underline;
2551
2552 void init() {
2553 use_underline = false;
2554 }
2555
2556};
2557
2558
2559
2560class LiVESToggleButton : public LiVESButtonBase, public QCheckBox {};
2561
2562
2563
2564
2565class LiVESButton : public LiVESButtonBase, public QPushButton {
2566public:
2567
2568 LiVESButton() {
2569 init();
2570 }
2571
2572 LiVESButton(QString qs) {
2573 init();
2574 }
2575
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
2586private:
2587 LiVESWidget *layout;
2588 void init() {
2589 set_type(LIVES_WIDGET_TYPE_BUTTON);
2590 }
2591
2592};
2593
2594
2595
2596
2597class LiVESSpinButton : public LiVESButtonBase, public QDoubleSpinBox {
2598public:
2599
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
2614 LiVESAdjustment *get_adj() {
2615 return adj;
2616 }
2617
2618 void valueChanged(double value) {
2619 adj->freeze();
2620 adj->set_value(value);
2621 adj->thaw();
2622 }
2623
2624private:
2625 LiVESAdjustment *adj;
2626
2627 void init() {
2628 set_type(LIVES_WIDGET_TYPE_SPIN_BUTTON);
2629 }
2630
2631};
2632
2633
2634
2635
2636class LiVESRadioButton : public LiVESButtonBase, public QRadioButton {
2637public:
2638 LiVESRadioButton() {
2639 init();
2640 }
2641
2642 LiVESRadioButton(QString qs) {
2643 init();
2644 }
2645
2646 void set_group(LiVESSList *xlist) {
2647 slist = xlist;
2648 }
2649
2650 LiVESSList *get_list() {
2651 return slist;
2652 }
2653
2654
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
2661private:
2662 LiVESSList *slist;
2663
2664 void init() {
2665 //setCheckable(true);
2666 set_type(LIVES_WIDGET_TYPE_RADIO_BUTTON);
2667 }
2668
2669};
2670
2671
2672
2673class LiVESCheckButton : public LiVESToggleButton {
2674public:
2675
2676 LiVESCheckButton() {
2677 init();
2678 }
2679
2680 LiVESCheckButton(QString qs) {
2681 init();
2682 }
2683
2684private:
2685 void init() {
2686 set_type(LIVES_WIDGET_TYPE_CHECK_BUTTON);
2687 }
2688
2689};
2690
2691
2692
2693class LiVESButtonBox : public LiVESWidget, public QDialogButtonBox {
2694public:
2695 LiVESButtonBox() {
2696 set_type(LIVES_WIDGET_TYPE_BUTTON_BOX);
2697 }
2698
2699};
2700
2701
2702
2703class LiVESMenuBar : public LiVESWidget, public QMenuBar {
2704public:
2705 LiVESMenuBar() {
2706 set_type(LIVES_WIDGET_TYPE_MENU_BAR);
2707 }
2708
2709
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
2739class LiVESMenu : public LiVESWidget, public QMenu {
2740public:
2741 LiVESMenu() {
2742 set_type(LIVES_WIDGET_TYPE_MENU);
2743 }
2744
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
2770class LiVESTornOffMenu : public LiVESMenu {
2771public:
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
2800class LiVESMenuItem : public LiVESWidget, public QAction {
2801public:
2802 LiVESMenuItem(LiVESWidget *parent) : QAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2803 set_type(LIVES_WIDGET_TYPE_MENU_ITEM);
2804 }
2805
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
2818class LiVESToolItem : public LiVESWidget, public QHBoxLayout {
2819public:
2820 LiVESToolItem() {
2821 init();
2822 }
2823
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
2834private:
2835 LiVESWidget *layout;
2836
2837 void init() {
2838 set_type(LIVES_WIDGET_TYPE_TOOL_ITEM);
2839 }
2840};
2841
2842
2843
2844
2845typedef LiVESMenuItem LiVESImageMenuItem;
2846
2847
2848
2849class LiVESMenuToolButton : public LiVESToolItem, public QWidgetAction {
2850public:
2851
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
2865class LiVESCheckMenuItem : public LiVESWidget, public QAction {
2866public:
2867 LiVESCheckMenuItem(LiVESWidget *parent) : QAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2868 }
2869
2870 LiVESCheckMenuItem(const QString &text, LiVESWidget *parent) : QAction(text,
2871 static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2872 setText(text);
2873 }
2874
2875private:
2876 void init() {
2877 set_type(LIVES_WIDGET_TYPE_CHECK_MENU_ITEM);
2878 setCheckable(true);
2879 }
2880
2881
2882};
2883
2884
2885class LiVESRadioMenuItem : public LiVESMenuItem {
2886public:
2887
2888 LiVESRadioMenuItem(LiVESWidget *parent) : LiVESMenuItem(parent) {
2889 init();
2890 }
2891
2892 LiVESRadioMenuItem(const QString &text, LiVESWidget *parent) : LiVESMenuItem(text, parent) {
2893 init();
2894 setText(text);
2895 }
2896
2897
2898 void set_group(LiVESSList *xlist) {
2899 slist = xlist;
2900 }
2901
2902 LiVESSList *get_list() {
2903 return slist;
2904 }
2905
2906
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
2913private:
2914 LiVESSList *slist;
2915
2916 void init() {
2917 setCheckable(true);
2918 set_type(LIVES_WIDGET_TYPE_RADIO_MENU_ITEM);
2919 }
2920};
2921
2922
2923
2924
2925class LiVESCombo : public LiVESWidget, public QComboBox {
2926public:
2927 LiVESCombo() {
2928 set_type(LIVES_WIDGET_TYPE_COMBO);
2929 }
2930};
2931
2932
2933class LiVESHSeparator : public LiVESWidget, public QHBoxLayout {
2934public:
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
2946class LiVESVSeparator : public LiVESWidget, public QVBoxLayout {
2947public:
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
2959class LiVESTextBuffer : public LiVESWidget, public QTextDocument {
2960public:
2961
2962 LiVESTextBuffer() {
2963 insert = QTextCursor(this);
2964 }
2965
2966 QTextCursor get_cursor() {
2967 return insert;
2968 }
2969
2970private:
2971 QTextCursor insert;
2972
2973};
2974
2975
2976
2977class LiVESTextView : public LiVESWidget, public QTextEdit {
2978public:
2979
2980 LiVESTextView() {
2981 buff = new LiVESTextBuffer();
2982 }
2983
2984
2985 LiVESTextView(LiVESTextBuffer *xbuff) : QTextEdit(), buff(xbuff) {
2986 set_type(LIVES_WIDGET_TYPE_TEXT_VIEW);
2987 setDocument(buff);
2988 }
2989
2990 ~LiVESTextView() {
2991 delete buff;
2992 }
2993
2994
2995 LiVESTextBuffer *get_buffer() {
2996 return buff;
2997 }
2998
2999private:
3000 LiVESTextBuffer *buff;
3001
3002 void init() {
3003 set_type(LIVES_WIDGET_TYPE_TEXT_VIEW);
3004 setDocument(buff);
3005 }
3006
3007
3008};
3009
3010
3011
3012class LiVESTextMark : public LiVESWidgetObject, public QTextCursor {
3013public:
3014
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
3020 ~LiVESTextMark() {
3021 delete name;
3022 }
3023
3024 QString get_name() {
3025 return name;
3026 }
3027
3028private:
3029 const char *name;
3030 boolean lgrav;
3031
3032};
3033
3034
3035
3036class LiVESRange : public LiVESWidget {
3037 Q_OBJECT
3038
3039public:
3040 LiVESRange(LiVESAdjustment *adj) {
3041 init(adj);
3042 }
3043
3044 virtual void init(LiVESAdjustment *adj) {}
3045
3046 LiVESAdjustment *get_adj() {
3047 return adj;
3048 }
3049
3050public slots:
3051 void valueChanged(int value) {
3052 adj->freeze();
3053 adj->set_value(value);
3054 adj->thaw();
3055 }
3056
3057private:
3058 LiVESAdjustment *adj;
3059
3060};
3061
3062
3063class LiVESScale : public LiVESRange, public QSlider {
3064 // TODO - add a label
3065public:
3066 LiVESScale(Qt::Orientation, LiVESAdjustment *xadj) : LiVESRange(xadj) {
3067 set_type(LIVES_WIDGET_TYPE_SCALE);
3068 }
3069
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
3081class LiVESScrollbar : public LiVESRange, public QScrollBar {
3082public:
3083 LiVESScrollbar(Qt::Orientation, LiVESAdjustment *xadj) : LiVESRange(xadj) {
3084 set_type(LIVES_WIDGET_TYPE_SCROLLBAR);
3085 }
3086
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
3098typedef LiVESScrollbar LiVESHScrollbar;
3099
3100
3101class LiVESEntry : public LiVESWidget, public QLineEdit {
3102public:
3103 LiVESEntry() {
3104 set_type(LIVES_WIDGET_TYPE_ENTRY);
3105 }
3106};
3107
3108
3109class LiVESProgressBar : public LiVESWidget, public QProgressBar {
3110public:
3111 LiVESProgressBar() {
3112 set_type(LIVES_WIDGET_TYPE_PROGRESS_BAR);
3113 }
3114};
3115
3116
3117class LiVESPaned : public LiVESWidget, public QSplitter {
3118public:
3119
3120 LiVESPaned() {
3121 set_type(LIVES_WIDGET_TYPE_PANED);
3122 }
3123};
3124
3125
3126class LiVESLabel : public LiVESWidget, public QLabel {
3127public:
3128 LiVESLabel(QString qstring) {
3129 set_type(LIVES_WIDGET_TYPE_LABEL);
3130 }
3131
3132 LiVESWidget *get_mnemonic_widget() {
3133 return mnemonicw;
3134 }
3135
3136 void set_mnemonic_widget(LiVESWidget *widget) {
3137 mnemonicw = widget;
3138 }
3139
3140 void set_owner(LiVESWidget *xowner) {
3141 owner = xowner;
3142 }
3143
3144 LiVESWidget *get_owner() {
3145 return owner;
3146 }
3147
3148 void set_text(QString text) {
3149 // if we have an owner, update owner text
3150 // TODO
3151 }
3152
3153
3154private:
3155 LiVESWidget *mnemonicw;
3156 LiVESWidget *owner; // TODO
3157};
3158
3159
3160class LiVESRuler : public LiVESWidget, public QSlider {
3161public:
3162 LiVESRuler() {
3163 set_type(LIVES_WIDGET_TYPE_RULER);
3164 }
3165};
3166
3167
3168
3169
3170class LiVESScrolledWindow : public LiVESWidget, public QScrollArea {
3171public:
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
3193 LiVESAdjustment *get_hadj() {
3194 return hadj;
3195 }
3196
3197 LiVESAdjustment *get_vadj() {
3198 return vadj;
3199 }
3200
3201private:
3202 LiVESAdjustment *hadj;
3203 LiVESAdjustment *vadj;
3204
3205};
3206
3207
3208
3209
3210
3211class LiVESToolButton : public LiVESToolItem, public QToolButton {
3212public:
3213
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
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
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
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
3274 bool get_use_underline() {
3275 return use_underline;
3276 }
3277
3278private:
3279 bool use_underline;
3280
3281 void init() {
3282 use_underline = false;
3283 }
3284
3285private:
3286 LiVESWidget *icon_widget;
3287 LiVESLabel *label_widget;
3288 LiVESVBox *layout;
3289
3290};
3291
3292
3293
3294
3295
3296
3297
3298typedef class LiVESWindow LiVESWindow;
3299
3300class LiVESAccelGroup {
3301public:
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
3312private:
3313 QList<LiVESWidgetObject *>widgets;
3314 QList<LiVESAccel *>accels;
3315
3316
3317};
3318
3319
3320
3321
3322void 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
3330boolean 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
3341boolean 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
3357QList<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
3367class LiVESWindow : public LiVESWidget {};
3368
3369typedef int LiVESWindowPosition;
3370#define LIVES_WIN_POS_DEFAULT 0
3371#define LIVES_WIN_POS_CENTER_ALWAYS 1
3372
3373
3374class LiVESMainWindow : public LiVESWindow, public QMainWindow {
3375public:
3376 LiVESMainWindow() {
3377 set_type(LIVES_WIDGET_TYPE_MAIN_WINDOW);
3378 set_position(LIVES_WIN_POS_DEFAULT);
3379 }
3380
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
3391 void set_position(LiVESWindowPosition xpos) {
3392 pos = xpos;
3393 }
3394
3395 LiVESWindowPosition get_position() {
3396 return pos;
3397 }
3398
3399
3400private:
3401 LiVESWidget *layout;
3402 LiVESWindowPosition pos;
3403
3404};
3405
3406
3407
3408void 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
3414void LiVESAccelGroup::add_widget(LiVESWidgetObject *window) {
3415 widgets.push_back(window);
3416}
3417
3418
3419void LiVESAccelGroup::remove_all_accelerators(LiVESWidgetObject *object) {
3420 while (accels.size() > 0) {
3421 object->remove_accel(accels.at(0));
3422 }
3423}
3424
3425
3426void LiVESAccelGroup::remove_widget(LiVESWidgetObject *window) {
3427 widgets.removeAll(window);
3428}
3429
3430
3431LiVESAccelGroup::~LiVESAccelGroup() {
3432 while (widgets.size() > 0) {
3433 remove_all_accelerators(widgets.at(0));
3434 }
3435}
3436
3437
3438class LiVESVLayout: public LiVESWidget, public QVBoxLayout {};
3439
3440class LiVESDialog : public LiVESWindow, public QDialog {
3441public:
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
3465 LiVESWidget *get_content_area() {
3466 return contentArea;
3467 }
3468
3469 LiVESWidget *get_action_area() {
3470 return actionArea;
3471 }
3472
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
3483private:
3484 LiVESWidget *layout;
3485 LiVESWidget *contentArea;
3486 LiVESWidget *actionArea;
3487};
3488
3489
3490typedef int LiVESDialogFlags;
3491typedef 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
3499typedef int LiVESButtonsType;
3500#define LIVES_BUTTONS_NONE 0
3501
3502class LiVESMessageDialog : public LiVESWindow, public QMessageBox {
3503public:
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
3527 LiVESWidget *get_content_area() {
3528 return contentArea;
3529 }
3530
3531 LiVESWidget *get_action_area() {
3532 return actionArea;
3533 }
3534
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
3545private:
3546 LiVESWidget *layout;
3547 LiVESWidget *contentArea;
3548 LiVESWidget *actionArea;
3549};
3550
3551
3552typedef void LiVESAboutDialog;
3553
3554
3555class LiVESAlignment: public LiVESWidget, public QGridLayout {
3556public:
3557 float xalign, yalign, xscale, yscale;
3558
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
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
3582class LiVESImage : public LiVESWidget, public QImage {
3583public:
3584
3585 LiVESImage() {
3586 init();
3587 }
3588
3589 LiVESImage(QImage *lim) {
3590 init();
3591 };
3592
3593 LiVESImage(int width, int height, QImage::Format fmt) {
3594 init();
3595 }
3596
3597 LiVESImage(uint8_t *data, int width, int height, int bpl, QImage::Format fmt, QImageCleanupFunction cleanupFunction,
3598 livespointer cleanupInfo) {
3599 init();
3600 }
3601
3602private:
3603 void init() {
3604 set_type(LIVES_WIDGET_TYPE_IMAGE);
3605 }
3606
3607};
3608
3609
3610
3611
3612class LiVESArrow : public LiVESImage {
3613public:
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
3626typedef struct {
3627 const char *attr;
3628 int col;
3629} tvattrcol;
3630
3631typedef 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
3637typedef class LiVESTreeView LiVESTreeView;
3638typedef LiVESTreeView LiVESTreeSelection;
3639
3640
3641class LiVESTreeViewColumn : public LiVESWidgetObject, public QStyledItemDelegate {
3642 friend LiVESTreeView;
3643
3644public:
3645
3646 LiVESTreeViewColumn(int rendertype) {
3647 fwidth = -1;
3648 }
3649
3650 void set_title(const char *xtitle) {
3651 title = strdup(xtitle);
3652 }
3653
3654 void set_expand(boolean xexpand) {
3655 expand = xexpand;
3656 }
3657
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
3665 void set_sizing(LiVESTreeViewColumnSizing xsizing) {
3666 sizing = xsizing;
3667 }
3668
3669
3670 void set_fixed_width(int xfwidth) {
3671 fwidth = xfwidth;
3672 }
3673
3674
3675 QList<tvattrcol *> get_attributes() {
3676 return attributes;
3677 }
3678
3679
3680 ~LiVESTreeViewColumn() {
3681 delete title;
3682 for (int i = 0; i < attributes.size(); i++) {
3683 delete attributes[i]->attr;
3684 }
3685 }
3686
3687
3688protected:
3689 int fwidth;
3690 int rendertype;
3691 LiVESTreeViewColumnSizing sizing;
3692 QList<tvattrcol *>attributes;
3693 const char *title;
3694 boolean expand;
3695};
3696
3697
3698typedef LiVESTreeViewColumn LiVESCellRenderer;
3699
3700
3701typedef 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
3707typedef class LiVESTreeStore LiVESTreeStore;
3708
3709
3710class LiVESTreeModel : public LiVESWidgetObject, public QStandardItemModel {
3711 friend LiVESTreeStore;
3712
3713public:
3714
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
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
3729protected:
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
3737private:
3738 LiVESTreeView *widget;
3739 QList<int> coltypes;
3740
3741};
3742
3743
3744typedef LiVESTreeModel LiVESListModel;
3745
3746
3747class LiVESTreeView : public LiVESWidget, public QTreeWidget {
3748 //Q_OBJECT
3749
3750public:
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
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
3775 LiVESTreeModel *get_model() {
3776 return model;
3777 }
3778
3779
3780
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
3823 LiVESAdjustment *get_hadj() {
3824 return hadj;
3825 }
3826
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
3847private:
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
3860typedef QTreeWidgetItem LiVESTreeIter;
3861
3862void LiVESTreeModel::set_tree_widget(LiVESTreeView *twidget) {
3863 widget = twidget;
3864}
3865
3866QTreeWidget *LiVESTreeModel::get_qtree_widget() {
3867 return static_cast<QTreeWidget *>(widget);
3868}
3869
3870
3871
3872class LiVESTreeStore : public LiVESTreeModel {
3873public:
3874 LiVESTreeStore(int ncols, int *types) {}
3875
3876};
3877
3878
3879class LiVESListStore : public LiVESListModel {
3880public:
3881 LiVESListStore(int ncols, int *types) {}
3882
3883};
3884
3885
3886
3887
3888
3889void 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
3919void 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
3953void 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
3984void 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
4015void 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
4043void 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
4054class LiVESTable : public LiVESWidget, public QGridLayout {
4055
4056public:
4057 LiVESTable() {
4058 set_type(LIVES_WIDGET_TYPE_TABLE);
4059 }
4060
4061
4062private:
4063 LiVESWidget *layout;
4064
4065};
4066
4067
4068typedef QWindow LiVESXWindow;
4069
4070typedef class LiVESImage LiVESPixbuf;
4071
4072typedef LiVESWidget LiVESEditable;
4073typedef LiVESWidget LiVESContainer;
4074typedef LiVESWidget LiVESMenuShell;
4075typedef LiVESWidget LiVESBin;
4076
4077typedef QSlider LiVESScaleButton; // TODO - create
4078typedef void LiVESExpander; // TODO - create
4079
4080
4081void 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
4098void 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
4117typedef 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
4123class LiVESFrame : public LiVESWidget, public QGroupBox {
4124public:
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
4133 void set_label(QString text) {
4134 label_widget->set_text(text);
4135 }
4136
4137
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
4154 LiVESWidget *get_label_widget() {
4155 return static_cast<LiVESWidget *>(label_widget);
4156 }
4157
4158
4159
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
4171private:
4172 LiVESWidget *layout;
4173 LiVESLabel *label_widget;
4174
4175
4176};
4177
4178
4179class LiVESFileChooser : public LiVESWidget, public QFileDialog {
4180public:
4181 LiVESFileChooser() {
4182 set_type(LIVES_WIDGET_TYPE_FILE_CHOOSER);
4183 }
4184
4185};
4186
4187
4188typedef 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
4196class LiVESNotebook : public LiVESWidget, public QTabWidget {
4197public:
4198
4199 LiVESNotebook() {
4200 set_type(LIVES_WIDGET_TYPE_NOTEBOOK);
4201 }
4202
4203 ~LiVESNotebook() {
4204 for (int i = 0; i < label_widgets.size(); i++) {
4205 label_widgets[i]->dec_refcount();
4206 }
4207 }
4208
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
4224 void append_page() {
4225 LiVESWidget *label_widget = new LiVESLabel(NULL);
4226 label_widgets.append(label_widget);
4227 }
4228
4229private:
4230 QList <LiVESWidget *> label_widgets;
4231
4232
4233};
4234
4235
4236
4237class LiVESToolbar : public LiVESWidget, public QToolBar {
4238public:
4239
4240 LiVESToolbar() {
4241 set_type(LIVES_WIDGET_TYPE_TOOLBAR);
4242 }
4243
4244 void add_action(QAction *act, int pos) {
4245 actions.insert(pos, act);
4246 }
4247
4248 QAction *get_action(int pos) {
4249 return actions.at(pos);
4250 }
4251
4252 int num_actions() {
4253 return actions.size();
4254 }
4255
4256private:
4257 QList<QAction *>actions;
4258
4259
4260};
4261
4262
4263
4264class LiVESColorButton : public LiVESButtonBase, public QPushButton {
4265 //Q_OBJECT
4266
4267public:
4268
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
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
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
4300 QColor get_colour() {
4301 return colour;
4302 }
4303
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
4312 void set_title(const char *xtitle) {
4313 title = QString::fromUtf8(xtitle);
4314 }
4315
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
4338private:
4339 QColor colour;
4340 boolean use_alpha;
4341 QString title;
4342};
4343
4344
4345
4346class LiVESTimer : public LiVESWidgetObject, public QTimer {
4347public:
4348
4349 LiVESTimer(uint32_t interval, LiVESWidgetSourceFunc xfunc, livespointer data);
4350
4351 uint32_t get_handle() {
4352 return handle;
4353 }
4354
4355 /* public slots:*/
4356
4357 void update();
4358
4359
4360private:
4361 uint32_t handle;
4362 LiVESWidgetSourceFunc func;
4363 livespointer data;
4364
4365};
4366
4367static QList<LiVESTimer *> static_timers;
4368
4369
4370LiVESTimer::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
4383void 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
4393void 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
4403typedef Qt::ToolButtonStyle LiVESToolbarStyle;
4404#define LIVES_TOOLBAR_ICONS Qt::ToolButtonIconOnly
4405#define LIVES_TOOLBAR_TEXT Qt::ToolButtonTextOnly
4406
4407typedef QSize LiVESRequisition;
4408
4409typedef int LiVESTextIter;
4410
4411class LiVESTreePath {
4412public:
4413
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
4426 LiVESTreePath(QList<int> qli) {
4427 init(qli);
4428 }
4429
4430 ~LiVESTreePath() {
4431 delete indices;
4432 }
4433
4434
4435 int get_depth() {
4436 return cnt;
4437 }
4438
4439
4440 int *get_indices() {
4441 return indices;
4442 }
4443
4444private:
4445 int *indices;
4446 int cnt;
4447
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
4459typedef Qt::Orientation LiVESOrientation;
4460#define LIVES_ORIENTATION_HORIZONTAL Qt::Horizontal
4461#define LIVES_ORIENTATION_VERTICAL Qt::Vertical
4462
4463typedef 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
4471typedef 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
4479typedef int LiVESWindowType;
4480#define LIVES_WINDOW_TOPLEVEL Qt::Window
4481#define LIVES_WINDOW_POPUP Qt::Popup
4482
4483typedef 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
4492typedef 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
4592char LIVES_STOCK_LABEL_OK[32];
4593char LIVES_STOCK_LABEL_YES[32];
4594char LIVES_STOCK_LABEL_NO[32];
4595char LIVES_STOCK_LABEL_SAVE[32];
4597char LIVES_STOCK_LABEL_OPEN[32];
4598char LIVES_STOCK_LABEL_QUIT[32];
4605
4606
4607typedef 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
4617typedef bool LiVESWrapMode;
4618#define LIVES_WRAP_NONE false
4619#define LIVES_WRAP_WORD true
4620
4621typedef 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
4628extern "C" {
4629 boolean lives_container_remove(LiVESContainer *, LiVESWidget *);
4630}
4631
4632
4633LiVESWidget::~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
4681typedef class lives_painter_t lives_painter_t;
4682
4683class LingoLayout : public LiVESWidgetObject {
4684public:
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
4692 void set_alignment(int xalign) {
4693 align = xalign;
4694 }
4695
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
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
4712private:
4713 QString text;
4714 QFont font;
4715 int align;
4716 int x, y, width, height;
4717};
4718
4719LIVES_INLINE void lingo_layout_set_alignment(LingoLayout *l, int alignment) {
4720 l->set_alignment(alignment);
4721}
4722
4723
4724LIVES_INLINE void lingo_layout_set_text(LingoLayout *l, const char *text, ssize_t len) {
4725 l->set_text(text, len);
4726}
4727
4728
4729LIVES_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
4734LIVES_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
4739LIVES_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
4752static void imclean(livespointer data) {
4753 lives_free(data);
4754}
4755
4756typedef 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
4762class lives_painter_surface_t : public QImage, public LiVESWidgetObject {
4763public:
4764 int refcount;
4765
4766 lives_painter_surface_t(int width, int height, QImage::Format fmt) : QImage(width, height, fmt) {
4767 refcount = 0;
4768 }
4769
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
4778boolean lives_painter_surface_destroy(lives_painter_surface_t *);
4779
4780
4781class lives_painter_t : public QPainter {
4782public:
4783 QPainterPath *p;
4784 lives_painter_surface_t *target;
4785 QPen pen;
4786
4787
4788 lives_painter_t(QWidget *widget) : QPainter(widget) {
4789 init();
4790 };
4791
4792
4793 lives_painter_t(lives_painter_surface_t *surf) : QPainter() {
4794 init();
4795 target = surf;
4796 };
4797
4798
4799 ~lives_painter_t() {
4800 if (target != NULL) lives_painter_surface_destroy(target);
4801 delete p;
4802 }
4803
4804
4805private:
4806
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
4819typedef 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
4829typedef 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
4837void 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
4845void 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
error("LSD_RANDFUNC(ptr, size) must be defined")
#define lives_free
Definition: machinestate.h:52
#define lives_malloc
Definition: machinestate.h:46
#define lives_realloc
Definition: machinestate.h:49
#define LIVES_INLINE
Definition: main.h:238
#define ulong
Definition: main.h:178
#define lives_strdup_printf(fmt,...)
Definition: support.c:27
LIVES_GLOBAL_INLINE char * translate_with_plural(const char *String, const char *StringPlural, unsigned long int n)
Definition: support.c:42
LIVES_GLOBAL_INLINE char * translate(const char *String)
Definition: support.c:31
#define dngettext(Domain, Message, MsgPlur, n)
Definition: support.h:41
#define dgettext(Domain, Message)
Definition: support.h:40
int boolean
Definition: videoplugin.h:54
#define TRUE
Definition: videoplugin.h:59
#define FALSE
Definition: videoplugin.h:60
WIDGET_HELPER_GLOBAL_INLINE boolean lives_container_remove(LiVESContainer *container, LiVESWidget *widget)
WIDGET_HELPER_GLOBAL_INLINE uint32_t lives_idle_add(LiVESWidgetSourceFunc function, livespointer data)
WIDGET_HELPER_GLOBAL_INLINE boolean lives_painter_surface_destroy(lives_painter_surface_t *surf)
WIDGET_HELPER_GLOBAL_INLINE LiVESWidgetColor * lives_widget_color_copy(LiVESWidgetColor *c1, const LiVESWidgetColor *c2)
WIDGET_HELPER_GLOBAL_INLINE uint32_t lives_timer_add(uint32_t interval, LiVESWidgetSourceFunc function, livespointer data)
char LIVES_STOCK_LABEL_SAVE_AS[32]
char LIVES_STOCK_LABEL_REVERT[32]
char LIVES_STOCK_LABEL_QUIT[32]
char LIVES_STOCK_LABEL_CLOSE[32]
char LIVES_STOCK_LABEL_GO_FORWARD[32]
char LIVES_STOCK_LABEL_APPLY[32]
char LIVES_STOCK_LABEL_YES[32]
char LIVES_STOCK_LABEL_DELETE[32]
ulong lives_signal_connect(LiVESWidget *, const char *signal_name, ulong funcptr, livespointer data)
char LIVES_STOCK_LABEL_REFRESH[32]
char LIVES_STOCK_LABEL_OPEN[32]
char LIVES_STOCK_LABEL_SAVE[32]
char LIVES_STOCK_LABEL_NO[32]
char LIVES_STOCK_LABEL_CANCEL[32]
stock labels, these are set up in widget_helper_init()
char LIVES_STOCK_LABEL_OK[32]