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 
24 using namespace std;
25 
26 #include <QtCore/QLinkedList>
27 
28 #include <QtGui/QScreen>
29 #include <QtGui/QWindow>
30 #include <QtGui/QTextCursor>
31 #include <QtGui/QTextDocumentFragment>
32 #include <QtGui/QShortcutEvent>
33 #include <QtGui/QWheelEvent>
34 #include <QtGui/QImageWriter>
35 #include <QtGui/QImageReader>
36 #include <QtCore/QDebug>
37 #include <QtCore/QTime>
38 #include <QtGui/QFont>
39 #include <QtGui/QFontDatabase>
40 #include <QtCore/QStandardPaths>
41 #include <QtCore/QLocale>
42 #include <QtCore/QMutableLinkedListIterator>
43 
44 #include <QtWidgets/QApplication>
45 #include <QtWidgets/QDesktopWidget>
46 #include <QtWidgets/QCompleter>
47 #include <QtWidgets/QLabel>
48 #include <QtWidgets/QColorDialog>
49 #include <QtWidgets/QWidget>
50 #include <QtWidgets/QWidgetAction>
51 #include <QtWidgets/QStyledItemDelegate>
52 #include <QtWidgets/QHeaderView>
53 #include <QtWidgets/QSplitter>
54 #include <QtWidgets/QLineEdit>
55 #include <QtWidgets/QPushButton>
56 #include <QtWidgets/QToolButton>
57 #include <QtWidgets/QToolBar>
58 #include <QtWidgets/QTableWidget>
59 #include <QtWidgets/QDialog>
60 #include <QtWidgets/QMessageBox>
61 #include <QtWidgets/QDialogButtonBox>
62 #include <QtWidgets/QBoxLayout>
63 #include <QtWidgets/QComboBox>
64 #include <QtWidgets/QMenu>
65 #include <QtWidgets/QMenuBar>
66 #include <QtWidgets/QLabel>
67 #include <QtWidgets/QMainWindow>
68 #include <QtWidgets/QFileDialog>
69 #include <QtWidgets/QLayout>
70 #include <QtWidgets/QTextEdit>
71 #include <QtWidgets/QTreeWidget>
72 #include <QtWidgets/QRadioButton>
73 #include <QtWidgets/QButtonGroup>
74 #include <QtWidgets/QProgressBar>
75 #include <QtWidgets/QDoubleSpinBox>
76 #include <QtWidgets/QCheckBox>
77 #include <QtWidgets/QShortcut>
78 #include <QtWidgets/QGridLayout>
79 #include <QtWidgets/QFrame>
80 #include <QtWidgets/QGroupBox>
81 #include <QtWidgets/QScrollArea>
82 #include <QtWidgets/QScrollBar>
83 
84 #include <QtGui/QColor>
85 #include <QtCore/QAbstractItemModel>
86 #include <QtWidgets/QAbstractSlider>
87 #include <QtWidgets/QAbstractButton>
88 #include <QtCore/QSharedPointer>
89 #include <QtGui/QStandardItemModel>
90 #include <QtCore/QModelIndex>
91 #include <QtCore/QTimer>
92 #include <QtCore/QThread>
93 #include <QtCore/QProcess>
94 #include <QtCore/QAbstractNativeEventFilter>
95 #include <QtCore/QCoreApplication>
96 
97 QApplication *qapp;
98 QTime *qtime;
99 
100 #define GTK_CHECK_VERSION(a,b,c) 1
101 
102 #define LIVES_LITTLE_ENDIAN 0
103 #define LIVES_BIG_ENDIAN 1
104 
105 #define LIVES_MAXINT INT_MAX
106 #define LIVES_MAXUINT32 UINT32_MAX
107 #define LIVES_MAXSIZE SIZE_MAX
108 #define LIVES_MAXFLOAT FLT_MAX
109 
110 #define LIVES_UNLIKELY(a) Q_UNLIKELY(a)
111 #define LIVES_LIKELY(a) Q_LIKELY(a)
112 
113 #define MAX_CURSOR_WIDTH 32
114 
115 #define G_GNUC_MALLOC
116 #define G_GNUC_PURE
117 #define G_GNUC_CONST
118 
119 typedef void *livespointer;
120 typedef const void *livesconstpointer;
121 
122 #define LIVES_INT_TO_POINTER(a) lives_int_to_pointer(a)
123 #define LIVES_UINT_TO_POINTER(a) lives_uint_to_pointer(a)
124 #define LIVES_POINTER_TO_INT(a) lives_pointer_to_int(a)
125 
126 LIVES_INLINE livespointer lives_int_to_pointer(int32_t a) {
127  return (livespointer)a;
128 }
129 
130 LIVES_INLINE livespointer lives_uint_to_pointer(uint32_t a) {
131  return (livespointer)a;
132 }
133 
134 LIVES_INLINE int32_t lives_pointer_to_int(livesconstpointer p) {
135  uint64_t xint = (uint64_t)p;
136  return (int32_t)(xint & 0xFFFF);
137 }
138 
139 typedef struct {
140  livespointer(*malloc)(size_t n_bytes);
141  livespointer(*realloc)(livespointer mem,
142  size_t n_bytes);
143  void (*free)(livespointer mem);
144  /* optional; set to NULL if not used ! */
145  livespointer(*calloc)(size_t n_blocks,
146  size_t n_block_bytes);
147  livespointer(*try_malloc)(size_t n_bytes);
148  livespointer(*try_realloc)(livespointer mem,
149  size_t n_bytes);
150 } LiVESMemVTable;
151 
152 LiVESMemVTable *static_alt_vtable;
153 
154 void (*lives_free)(livespointer ptr);
155 livespointer(*lives_malloc)(size_t size);
156 livespointer(*lives_realloc)(livespointer ptr, size_t new_size);
157 livespointer(*lives_try_malloc)(size_t size);
158 livespointer(*lives_try_realloc)(livespointer ptr, size_t new_size);
159 livespointer(_lives_calloc)(size_t n_blocks, size_t n_block_bytes);
160 
161 
162 livespointer malloc_wrapper(size_t size) {
163  livespointer ptr = (static_alt_vtable->malloc)(size);
164  Q_ASSERT(ptr != NULL);
165  return ptr;
166 }
167 
168 
169 livespointer realloc_wrapper(livespointer old_ptr, size_t new_size) {
170  livespointer ptr = (static_alt_vtable->realloc)(old_ptr, new_size);
171  Q_ASSERT(ptr != NULL);
172  return ptr;
173 }
174 
175 
176 livespointer try_malloc_wrapper(size_t size) {
177  return (static_alt_vtable->malloc)(size);
178 }
179 
180 
181 livespointer try_realloc_wrapper(livespointer old_ptr, size_t new_size) {
182  return (static_alt_vtable->realloc)(old_ptr, new_size);
183 }
184 
185 
186 LIVES_INLINE livespointer lives_malloc0(size_t size) {
187  livespointer ptr = (static_alt_vtable->calloc)(1, size);
188  Q_ASSERT(ptr != NULL);
189  return ptr;
190 }
191 
192 
193 LIVES_INLINE livespointer lives_try_malloc0(size_t size) {
194  return (static_alt_vtable->calloc)(1, size);
195 }
196 
197 
198 LIVES_INLINE livespointer lives_try_malloc0_n(size_t nmemb, size_t nmemb_bytes) {
199  return (static_alt_vtable->calloc)(nmemb, nmemb_bytes);
200 }
201 
202 
203 
204 #define NO_GTK
205 #include "support.h"
206 
207 extern char *trString;
208 
209 // TODO - move to support.c
210 char *translate(const char *String) {
211  delete trString; // be very careful, as trString is free()d automatically here
212  if (strlen(String)) {
213  QString qs = QString::fromLocal8Bit(dgettext(PACKAGE, String));
214  trString = strdup(qs.toUtf8().constData());
215  } else trString = strdup(String);
216  return trString;
217 }
218 
219 char *translate_with_plural(const char *String, const char *StringPlural, unsigned long int n) {
220  delete trString; // be very careful, as trString is free()d automatically here
221  if (strlen(String)) {
222  QString qs = QString::fromLocal8Bit(dngettext(PACKAGE, String, StringPlural, n));
223  trString = strdup(qs.toUtf8().constData());
224  } else trString = strdup(String);
225  return trString;
226 }
227 
228 
229 int lives_printerr(const char *format, ...) {
230  char *buff;
231  va_list args;
232  va_start(args, format);
233  int r = vasprintf(&buff, format, args);
234  va_end(args);
235  qDebug() << buff;
236  free(buff);
237  return r;
238 }
239 
240 
241 
242 #define lives_strdup(a) strdup(a)
243 #define lives_strndup(a,b) strndup(a,b)
244 
245 char *lives_strdup_printf(const char *format, ...) {
246  char *buff;
247  va_list args;
248  va_start(args, format);
249  int r = vasprintf(&buff, format, args);
250  r = r;
251  va_end(args);
252  return buff;
253 }
254 
255 int lives_snprintf(char *buff, size_t len, const char *format, ...) {
256  va_list args;
257  va_start(args, format);
258  int r = vsnprintf(buff, len, format, args);
259  va_end(args);
260  return r;
261 }
262 
263 
264 void lives_strfreev(char **str_array) {
265  if (str_array) {
266  for (int i = 0; str_array[i] != NULL; i++)
267  lives_free(str_array[i]);
268  lives_free(str_array);
269  }
270 }
271 
272 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
273 #define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
274 
275 int lives_ascii_strcasecmp(const char *s1, const char *s2) {
276  int c1, c2;
277 
278  while (*s1 && *s2) {
279  c1 = (int)(uint8_t) TOLOWER(*s1);
280  c2 = (int)(uint8_t) TOLOWER(*s2);
281  if (c1 != c2)
282  return (c1 - c2);
283  s1++;
284  s2++;
285  }
286  return (((int)(uint8_t) * s1) - ((int)(uint8_t) * s2));
287 }
288 
289 
290 int lives_ascii_strncasecmp(const char *s1, const char *s2, size_t len) {
291  int c1, c2;
292 
293  while (len && *s1 && *s2) {
294  len--;
295  c1 = (int)(uint8_t) TOLOWER(*s1);
296  c2 = (int)(uint8_t) TOLOWER(*s2);
297  if (c1 != c2)
298  return (c1 - c2);
299  s1++;
300  s2++;
301  }
302  if (len) return (((int)(uint8_t) * s1) - ((int)(uint8_t) * s2));
303  else return 0;
304 }
305 
306 
307 char *lives_strconcat(const char *string1, ...) {
308  size_t l;
309  va_list args;
310  char *s;
311  char *concat;
312  char *ptr;
313  if (!string1)
314  return NULL;
315  l = 1 + strlen(string1);
316  va_start(args, string1);
317  s = va_arg(args, char *);
318  while (s) {
319  l += strlen(s);
320  s = va_arg(args, char *);
321  }
322  va_end(args);
323  concat = (char *)malloc(l);
324  ptr = concat;
325  ptr = stpcpy(ptr, string1);
326  va_start(args, string1);
327  s = va_arg(args, char *);
328  while (s) {
329  ptr = stpcpy(ptr, s);
330  s = va_arg(args, char *);
331  }
332  va_end(args);
333  return concat;
334 }
335 
336 
337 
338 char *lives_build_filename(const char *first, ...) {
339  char *fname = strdup(""), *tmp;
340  char *piece;
341  char sep = '/';
342  va_list args;
343 
344 #ifdef IS_MINGW
345  va_start(args, first);
346  while (1) {
347  piece = va_arg(args, char *);
348  if (piece == NULL) break;
349  if (strstr(piece, "\\")) {
350  sep = '\\';
351  break;
352  }
353  }
354  va_end(args);
355 #endif
356 
357  va_start(args, first);
358  while (1) {
359  piece = va_arg(args, char *);
360  if (piece == NULL) break;
361  tmp = lives_strdup_printf("%s%s%s", fname, sep, piece);
362  lives_free(fname);
363  fname = tmp;
364  }
365  va_end(args);
366 
367  QString qs(fname);
368  lives_free(fname);
369 #ifdef IS_MINGW
370  fname = strdup(QDir::cleanPath(qs).toUtf8().constData());
371 #else
372  fname = strdup(QDir::cleanPath(qs).toLocal8Bit().constData());
373 #endif
374  return fname;
375 }
376 
377 
378 char *lives_strstrip(char *string) {
379  QString qs = QString::fromUtf8(string);
380  qs.trimmed();
381  memcpy(string, qs.toUtf8().constData(), qs.toUtf8().size());
382  return string;
383 }
384 
385 
386 char *lives_strrstr(const char *haystack, const char *needle) {
387  size_t i;
388  size_t needle_len;
389  size_t haystack_len;
390  const char *p;
391  needle_len = strlen(needle);
392  haystack_len = strlen(haystack);
393  if (needle_len == 0)
394  return (char *)haystack;
395  if (haystack_len < needle_len)
396  return NULL;
397  p = haystack + haystack_len - needle_len;
398  while (p >= haystack) {
399  for (i = 0; i < needle_len; i++)
400  if (p[i] != needle[i])
401  goto next;
402  return (char *)p;
403 next:
404  p--;
405  }
406  return NULL;
407 }
408 
409 
410 
411 LIVES_INLINE char *lives_filename_to_utf8(const char *ostr, ssize_t len, size_t *bytes_read, size_t *bytes_written,
412  void *error) {
413 #ifndef IS_MINGW
414  QString qs = QString::fromLocal8Bit(ostr);
415  return strdup(qs.toUtf8().constData());
416 #endif
417  return strdup(ostr);
418 }
419 
420 
421 LIVES_INLINE char *lives_filename_from_utf8(const char *ostr, ssize_t len, size_t *bytes_read, size_t *bytes_written,
422  void *error) {
423 #ifndef IS_MINGW
424  QString qs = QString::fromUtf8(ostr);
425  return strdup(qs.toLocal8Bit().constData());
426 #endif
427  return strdup(ostr);
428 }
429 
430 
431 char *L2U8(const char *local_string) {
432 #ifndef IS_MINGW
433  QString qs = QString::fromLocal8Bit(local_string);
434  return strdup(qs.toUtf8().constData());
435 #else
436  return local_string;
437 #endif
438 }
439 
440 char *U82L(const char *utf8_string) {
441 #ifndef IS_MINGW
442  QString qs = QString::fromUtf8(utf8_string);
443  return strdup(qs.toLocal8Bit().constData());
444 #else
445  return utf8_string;
446 #endif
447 }
448 
449 
450 char *lives_utf8_strdown(char *string, size_t len) {
451  QString qs = QString::fromUtf8(string);
452  qs.toLower();
453  return strdup(qs.toUtf8().constData());
454 }
455 
456 
457 
458 #define ABS(a) qAbs(a)
459 
460 
461 char *lives_find_program_in_path(const char *prog) {
462  QString qs = QStandardPaths::findExecutable(prog);
463  if (qs == "") return NULL;
464  return strdup(qs.toLocal8Bit().constData());
465 }
466 
467 
468 
469 
470 
471 
472 #ifndef IS_MINGW
473 typedef bool boolean;
474 #endif
475 
476 
477 typedef boolean(*LiVESWidgetSourceFunc)(livespointer data);
478 
479 typedef int (*LiVESCompareFunc)(livesconstpointer a, livesconstpointer b);
480 
481 #ifndef FALSE
482 #define FALSE false
483 #endif
484 
485 #ifndef TRUE
486 #define TRUE true
487 #endif
488 
489 
490 extern "C" {
491  uint32_t lives_timer_add(uint32_t interval, LiVESWidgetSourceFunc function, livespointer data);
492 }
493 
494 #define G_PRIORITY_LOW 0
495 #define G_PRIORITY_HIGH 1
496 
497 LIVES_INLINE uint32_t lives_idle_add_full(int prio, LiVESWidgetSourceFunc function, livespointer data, livespointer destnot) {
498  return lives_timer_add(0, function, data);
499 }
500 
501 
502 LIVES_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 
511 LIVES_INLINE void lives_set_application_name(const char *name) {
512  qapp->setApplicationName(QString::fromUtf8(name));
513 }
514 
515 
516 LIVES_INLINE const char *lives_get_application_name() {
517  return qapp->applicationName().toLocal8Bit().constData();
518 }
519 
520 
521 class SleeperThread : public QThread {
522 public:
523  static void msleep(unsigned long msecs) {
524  QThread::msleep(msecs);
525  }
526 };
527 
528 LIVES_INLINE void lives_usleep(ulong microsec) {
529  SleeperThread::msleep(microsec);
530 }
531 
532 
533 LIVES_INLINE int lives_mkdir_with_parents(const char *name, int mode) {
534 #ifndef IS_MINGW
535  mode_t omask = umask(mode);
536 #endif
537  QString qs = QString::fromUtf8(name);
538  QDir qd = QDir(qs);
539  bool ret = qd.mkpath(qs);
540 #ifndef IS_MINGW
541  umask(omask);
542 #endif
543  if (!ret) return -1;
544  return 0;
545 }
546 
547 #define lives_strtod(a,b) strtod(a,b)
548 
549 char *lives_path_get_basename(const char *path) {
550  QFileInfo qf(path);
551  QString qs = qf.fileName();
552  return strdup(qs.toUtf8().constData());
553 }
554 
555 char *lives_path_get_dirname(const char *path) {
556  QFileInfo qf(path);
557  QDir dir = qf.dir();
558  QString qs = dir.path();
559  return strdup(qs.toUtf8().constData());
560 }
561 
562 
563 typedef int LiVESFileTest;
564 #define LIVES_FILE_TEST_EXISTS 1
565 #define LIVES_FILE_TEST_IS_DIR 2
566 #define LIVES_FILE_TEST_IS_REGULAR 3
567 
568 
569 boolean lives_file_test(const char *fname, LiVESFileTest test) {
570  QFileInfo qf(fname);
571  if (test == LIVES_FILE_TEST_EXISTS) {
572  return qf.exists();
573  }
574  if (test == LIVES_FILE_TEST_IS_DIR) {
575  return qf.isDir();
576  }
577  if (test == LIVES_FILE_TEST_IS_REGULAR) {
578  return qf.isFile();
579  }
580  return FALSE;
581 }
582 
583 
584 char *lives_get_current_dir() {
585  QString qs = QDir::current().path();
586 #ifdef IS_MINGW
587  return strdup(qs.toUtf8().constData());
588 #else
589  return strdup(qs.toLocal8Bit().constData());
590 #endif
591 
592 }
593 
594 typedef struct {
595  ulong function;
596  livespointer data;
597 } LiVESClosure;
598 
599 typedef LiVESClosure LiVESWidgetClosure;
600 
601 
602 
604 
605 
606 typedef void (*LiVESPixbufDestroyNotify)(uchar *, livespointer);
607 
608 
609 typedef int lives_painter_content_t;
610 
611 
612 
613 typedef struct {
614  int code;
615  char *message;
616 } LiVESError;
617 
618 
619 LIVES_INLINE void lives_error_free(LiVESError *error) {
620  if (error->message != NULL) free(error->message);
621  free(error);
622 }
623 
624 #define lives_strerror(a) strerror(a)
625 
626 
627 typedef QScreen LiVESXScreen;
628 typedef QScreen LiVESXDisplay;
629 typedef QScreen LiVESXDevice;
630 
631 #ifndef HAVE_X11
632 typedef WId Window;
633 #endif
634 
635 typedef QFile LiVESIOChannel;
636 
637 
638 
639 //#define LIVES_TABLE_IS_GRID 1 // no "remove row" available
640 
641 
642 
643 typedef QStyle::StateFlag LiVESWidgetState;
644 
645 #define LIVES_WIDGET_STATE_NORMAL QStyle::State_Enabled
646 #define LIVES_WIDGET_STATE_ACTIVE QStyle::State_Active
647 #define LIVES_WIDGET_STATE_PRELIGHT QStyle::State_MouseOver
648 #define LIVES_WIDGET_STATE_SELECTED QStyle::State_Selected
649 
650 #define LIVES_WIDGET_STATE_INSENSITIVE QStyle::State_None
651 
652 #define LIVES_WIDGET_STATE_FOCUSED QStyle::State_HasFocus
653 
654 //#define LIVES_WIDGET_STATE_INCONSISTENT GTK_STATE_FLAG_INCONSISTENT
655 //#define LIVES_WIDGET_STATE_BACKDROP GTK_STATE_FLAG_BACKDROP
656 
657 #define LIVES_WIDGET_COLOR_HAS_ALPHA (1)
658 #define LIVES_WIDGET_COLOR_SCALE(x) (x)
659 #define LIVES_WIDGET_COLOR_SCALE_255(x) ((double)x/255.)
660 
661 
662 typedef Qt::KeyboardModifiers LiVESXModifierType;
663 
664 #define LIVES_CONTROL_MASK Qt::ControlModifier
665 #define LIVES_ALT_MASK Qt::AltModifier
666 #define LIVES_SHIFT_MASK Qt::ShiftModifier
667 #define LIVES_LOCK_MASK Qt::ShiftModifier
668 
669 
670 #define LIVES_KEY_Left (static_cast<uint32_t>(Qt::Key_Left))
671 #define LIVES_KEY_Right (static_cast<uint32_t>(Qt::Key_Right))
672 #define LIVES_KEY_Up (static_cast<uint32_t>(Qt::Key_Up))
673 #define LIVES_KEY_Down (static_cast<uint32_t>(Qt::Key_Down))
674 
675 #define LIVES_KEY_BackSpace (static_cast<uint32_t>(Qt::Key_Backspace))
676 #define LIVES_KEY_Return (static_cast<uint32_t>(Qt::Key_Return))
677 #define LIVES_KEY_Tab (static_cast<uint32_t>(Qt::Key_Tab))
678 #define LIVES_KEY_Home (static_cast<uint32_t>(Qt::Key_Home))
679 #define LIVES_KEY_End (static_cast<uint32_t>(Qt::Key_End))
680 #define LIVES_KEY_Slash (static_cast<uint32_t>(Qt::Key_Slash))
681 #define LIVES_KEY_Space (static_cast<uint32_t>(Qt::Key_Space))
682 #define LIVES_KEY_Plus (static_cast<uint32_t>(Qt::Key_Plus))
683 #define LIVES_KEY_Minus (static_cast<uint32_t>(Qt::Key_Minus))
684 #define LIVES_KEY_Equal (static_cast<uint32_t>(Qt::Key_Equal))
685 
686 #define LIVES_KEY_1 (static_cast<uint32_t>(Qt::Key_1))
687 #define LIVES_KEY_2 (static_cast<uint32_t>(Qt::Key_2))
688 #define LIVES_KEY_3 (static_cast<uint32_t>(Qt::Key_3))
689 #define LIVES_KEY_4 (static_cast<uint32_t>(Qt::Key_4))
690 #define LIVES_KEY_5 (static_cast<uint32_t>(Qt::Key_5))
691 #define LIVES_KEY_6 (static_cast<uint32_t>(Qt::Key_6))
692 #define LIVES_KEY_7 (static_cast<uint32_t>(Qt::Key_7))
693 #define LIVES_KEY_8 (static_cast<uint32_t>(Qt::Key_8))
694 #define LIVES_KEY_9 (static_cast<uint32_t>(Qt::Key_9))
695 #define LIVES_KEY_0 (static_cast<uint32_t>(Qt::Key_0))
696 
697 #define LIVES_KEY_a (static_cast<uint32_t>(Qt::Key_A))
698 #define LIVES_KEY_b (static_cast<uint32_t>(Qt::Key_B))
699 #define LIVES_KEY_c (static_cast<uint32_t>(Qt::Key_C))
700 #define LIVES_KEY_d (static_cast<uint32_t>(Qt::Key_D))
701 #define LIVES_KEY_e (static_cast<uint32_t>(Qt::Key_E))
702 #define LIVES_KEY_f (static_cast<uint32_t>(Qt::Key_F))
703 #define LIVES_KEY_g (static_cast<uint32_t>(Qt::Key_G))
704 #define LIVES_KEY_h (static_cast<uint32_t>(Qt::Key_H))
705 #define LIVES_KEY_i (static_cast<uint32_t>(Qt::Key_I))
706 #define LIVES_KEY_j (static_cast<uint32_t>(Qt::Key_J))
707 #define LIVES_KEY_k (static_cast<uint32_t>(Qt::Key_K))
708 #define LIVES_KEY_l (static_cast<uint32_t>(Qt::Key_L))
709 #define LIVES_KEY_m (static_cast<uint32_t>(Qt::Key_M))
710 #define LIVES_KEY_n (static_cast<uint32_t>(Qt::Key_N))
711 #define LIVES_KEY_o (static_cast<uint32_t>(Qt::Key_O))
712 #define LIVES_KEY_p (static_cast<uint32_t>(Qt::Key_P))
713 #define LIVES_KEY_q (static_cast<uint32_t>(Qt::Key_Q))
714 #define LIVES_KEY_r (static_cast<uint32_t>(Qt::Key_R))
715 #define LIVES_KEY_s (static_cast<uint32_t>(Qt::Key_S))
716 #define LIVES_KEY_t (static_cast<uint32_t>(Qt::Key_T))
717 #define LIVES_KEY_u (static_cast<uint32_t>(Qt::Key_U))
718 #define LIVES_KEY_v (static_cast<uint32_t>(Qt::Key_V))
719 #define LIVES_KEY_w (static_cast<uint32_t>(Qt::Key_W))
720 #define LIVES_KEY_x (static_cast<uint32_t>(Qt::Key_X))
721 #define LIVES_KEY_y (static_cast<uint32_t>(Qt::Key_Y))
722 #define LIVES_KEY_z (static_cast<uint32_t>(Qt::Key_Z))
723 
724 #define LIVES_KEY_F1 (static_cast<uint32_t>(Qt::Key_F1))
725 #define LIVES_KEY_F2 (static_cast<uint32_t>(Qt::Key_F2))
726 #define LIVES_KEY_F3 (static_cast<uint32_t>(Qt::Key_F3))
727 #define LIVES_KEY_F4 (static_cast<uint32_t>(Qt::Key_F4))
728 #define LIVES_KEY_F5 (static_cast<uint32_t>(Qt::Key_F5))
729 #define LIVES_KEY_F6 (static_cast<uint32_t>(Qt::Key_F6))
730 #define LIVES_KEY_F7 (static_cast<uint32_t>(Qt::Key_F7))
731 #define LIVES_KEY_F8 (static_cast<uint32_t>(Qt::Key_F8))
732 #define LIVES_KEY_F9 (static_cast<uint32_t>(Qt::Key_F9))
733 #define LIVES_KEY_F10 (static_cast<uint32_t>(Qt::Key_F10))
734 #define LIVES_KEY_F11 (static_cast<uint32_t>(Qt::Key_F11))
735 #define LIVES_KEY_F12 (static_cast<uint32_t>(Qt::Key_F12))
736 
737 #define LIVES_KEY_Page_Up (static_cast<uint32_t>(Qt::Key_PageUp))
738 #define LIVES_KEY_Page_Down (static_cast<uint32_t>(Qt::Key_PageDown))
739 
740 #define LIVES_KEY_Escape (static_cast<uint32_t>(Qt::Key_Escape))
741 
742 typedef int LiVESAccelFlags;
743 
744 typedef class LiVESAccelGroup LiVESAccelGroup;
745 typedef class LiVESWidget LiVESWidget;
746 
747 
748 typedef void LiVESXEvent;
749 typedef void LiVESXXEvent;
750 typedef void LiVESXEventMotion;
751 typedef void LiVESXEventFocus;
752 
753 typedef QCursor LiVESXCursor;
754 
755 
756 #define LIVES_SCROLL_UP 1
757 #define LIVES_SCROLL_DOWN 2
758 
759 typedef struct {
760  int direction;
761  LiVESXModifierType state;
762 } LiVESXEventScroll;
763 
764 
765 typedef struct {
766  int x;
767  int y;
768  int width;
769  int height;
770 } LiVESRect;
771 
772 
773 typedef struct {
774  int count;
775  LiVESRect area;
776 } LiVESXEventExpose;
777 
778 
779 typedef struct {
780  int time;
781  int type;
782  int button;
783 } LiVESXEventButton;
784 
785 #define LIVES_BUTTON_PRESS 1
786 #define LIVES_BUTTON_RELEASE 2
787 #define LIVES_BUTTON2_PRESS 3
788 
789 
790 typedef void LiVESXEventCrossing;
791 typedef void LiVESXEventConfigure;
792 typedef void LiVESXEventDelete;
793 
794 
795 typedef class LiVESWidgetObject LiVESWidgetObject;
796 
797 typedef void (*LiVESWidgetCallback)(LiVESWidget *widget, livespointer data);
798 
799 LiVESClosure *lives_cclosure_new(ulong func, livespointer data, livespointer dest_func) {
800  LiVESClosure *cl = new LiVESClosure;
801  cl->function = (ulong)func;
802  cl->data = data;
803 
804  return cl;
805  // TODO - something with dest_func: decref this when removed from accel, and call dest_func
806 }
807 
808 typedef boolean(*LiVESScrollEventCallback)(LiVESWidget *widget, LiVESXEventScroll *, livespointer data);
809 typedef boolean(*LiVESExposeEventCallback)(LiVESWidget *widget, LiVESXEventExpose *, livespointer data);
810 typedef boolean(*LiVESEnterEventCallback)(LiVESWidget *widget, LiVESXEventCrossing *, livespointer data);
811 typedef boolean(*LiVESButtonEventCallback)(LiVESWidget *widget, LiVESXEventButton *, livespointer data);
812 typedef boolean(*LiVESConfigureEventCallback)(LiVESWidget *widget, LiVESXEventConfigure *, livespointer data);
813 typedef boolean(*LiVESDeleteEventCallback)(LiVESWidget *widget, LiVESXEventDelete *, livespointer data);
814 typedef boolean(*LiVESAccelCallback)(LiVESAccelGroup *group, LiVESWidgetObject *obj, uint32_t keyval, LiVESXModifierType mod,
815  livespointer data);
816 
817 #define LIVES_GUI_CALLBACK(a) (ulong)(a)
818 
819 
820 typedef void LiVESTargetEntry;
821 
822 typedef bool LiVESFilterReturn;
823 
824 #define LIVES_FILTER_REMOVE true
825 #define LIVES_FILTER_CONTINUE false
826 
827 
828 typedef struct {
829  ulong handler_id; // set for signals, 0 for key accels
830  QKeySequence ks; // set for key accels
831  LiVESAccelFlags flags;
832  LiVESAccelGroup *group;
833  QShortcut *shortcut; // created for key accels
834 
835  // for key accels, one or the other of these: - either we emit accel_signal, or we call closure
836  // for normal signals, both are set (name of signal and the closure it calls)
837  const char *signal_name; // or NULL, if not NULL we emit signal (or is set for signal)
838  LiVESClosure *closure; // or NULL, if not NULL we call closure
839  bool blocked;
840 } LiVESAccel;
841 
842 
843 
844 typedef struct {
845  // values from 0.0 -> 1.0
846  double red;
847  double green;
848  double blue;
849  double alpha;
850 } LiVESWidgetColor;
851 
852 
853 boolean return_true() {
854  return TRUE;
855 }
856 
857 
858 typedef uint32_t LiVESEventMask;
859 #define LIVES_EXPOSURE_MASK (1<<0)
860 #define LIVES_POINTER_MOTION_MASK (1<<1)
861 #define LIVES_POINTER_MOTION_HINT_MASK (1<<2)
862 #define LIVES_BUTTON_MOTION_MASK (1<<3)
863 #define LIVES_BUTTON1_MOTION_MASK (1<<4)
864 #define LIVES_BUTTON2_MOTION_MASK (1<<5)
865 #define LIVES_BUTTON3_MOTION_MASK (1<<6)
866 #define LIVES_BUTTON_PRESS_MASK (1<<7)
867 #define LIVES_BUTTON_RELEASE_MASK (1<<8)
868 #define LIVES_KEY_PRESS_MASK (1<<9)
869 #define LIVES_KEY_RELEASE_MASK (1<<10)
870 #define LIVES_ENTER_NOTIFY_MASK (1<<11)
871 #define LIVES_LEAVE_NOTIFY_MASK (1<<12)
872 #define LIVES_FOCUS_CHANGE_MASK (1<<13)
873 #define LIVES_STRUCTURE_MASK (1<<14)
874 #define LIVES_PROPERTY_CHANGE_MASK (1<<15)
875 #define LIVES_VISIBILITY_NOTIFY_MASK (1<<16)
876 #define LIVES_PROXIMITY_IN_MASK (1<<17)
877 #define LIVES_PROXIMITY_OUT_MASK (1<<18)
878 #define LIVES_SUBSTRUCTURE_MASK (1<<19)
879 #define LIVES_SCROLL_MASK (1<<20)
880 #define LIVES_TOUCH_MASK (1<<21)
881 #define LIVES_SMOOTH_SCROLL_MASK (1<<22)
882 
883 #define LIVES_ALL_EVENTS_MASK 0xFFFF
884 
885 // events
886 #define LIVES_WIDGET_EXPOSE_EVENT "update"
887 #define LIVES_WIDGET_SCROLL_EVENT "scroll_event"
888 #define LIVES_WIDGET_ENTER_EVENT "enter-event"
889 #define LIVES_WIDGET_BUTTON_PRESS_EVENT "button-press-event"
890 #define LIVES_WIDGET_CONFIGURE_EVENT "resize"
891 #define LIVES_WIDGET_DELETE_EVENT "close-event"
892 
893 // TODO - add: "motion_notify_event", "button_release_event", "leave-notify-event", "drag-data-received", "focus-out-event", "edited"
894 
895 
896 // signals
897 #define LIVES_WIDGET_CLICKED_EVENT "clicked"
898 #define LIVES_WIDGET_TOGGLED_EVENT "toggled"
899 #define LIVES_WIDGET_CHANGED_EVENT "changed"
900 #define LIVES_WIDGET_ACTIVATE_EVENT "activate"
901 #define LIVES_WIDGET_VALUE_CHANGED_EVENT "value-changed"
902 #define LIVES_WIDGET_SELECTION_CHANGED_EVENT "selection-changed"
903 #define LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT "current-folder-changed"
904 #define LIVES_WIDGET_RESPONSE_EVENT "response"
905 
906 // add "unmap", "color-set", "drag-data-received", "mode-changed", "accept-position", "edited", "set-focus-child", "state-changed", "switch-page", "size-prepared"
907 
908 extern "C" {
909  LiVESWidgetColor *lives_widget_color_copy(LiVESWidgetColor *c1orNULL, const LiVESWidgetColor *c2);
910 }
911 
912 static QString make_col(LiVESWidgetColor *col) {
913  QString qc = QString("rgba(%1,%2,%3,%4)")
914  .arg(col->red * 255.)
915  .arg(col->green * 255.)
916  .arg(col->blue * 255.)
917  .arg(col->alpha * 255.);
918  return qc;
919 }
920 
921 
922 typedef enum {
923  LIVES_OBJECT_TYPE_UNKNOWN,
924  LIVES_OBJECT_TYPE_TIMER,
925  LIVES_WIDGET_TYPE_BUTTON,
926  LIVES_WIDGET_TYPE_SPIN_BUTTON,
927  LIVES_WIDGET_TYPE_RADIO_BUTTON,
928  LIVES_WIDGET_TYPE_CHECK_BUTTON,
929  LIVES_WIDGET_TYPE_COLOR_BUTTON,
930  LIVES_WIDGET_TYPE_TOOL_BUTTON,
931  LIVES_WIDGET_TYPE_TOOLBAR,
932  LIVES_WIDGET_TYPE_BUTTON_BOX,
933  LIVES_WIDGET_TYPE_TEXT_VIEW,
934  LIVES_WIDGET_TYPE_SCALE,
935  LIVES_WIDGET_TYPE_SCROLLBAR,
936  LIVES_WIDGET_TYPE_SCROLLED_WINDOW,
937  LIVES_WIDGET_TYPE_PROGRESS_BAR,
938  LIVES_WIDGET_TYPE_PANED,
939  LIVES_WIDGET_TYPE_MENU,
940  LIVES_WIDGET_TYPE_MENU_ITEM,
941  LIVES_WIDGET_TYPE_TOOL_ITEM,
942  LIVES_WIDGET_TYPE_RADIO_MENU_ITEM,
943  LIVES_WIDGET_TYPE_CHECK_MENU_ITEM,
944  LIVES_WIDGET_TYPE_MENU_TOOL_BUTTON,
945  LIVES_WIDGET_TYPE_MENU_BAR,
946  LIVES_WIDGET_TYPE_ENTRY,
947  LIVES_WIDGET_TYPE_FRAME,
948  LIVES_WIDGET_TYPE_FILE_CHOOSER,
949  LIVES_WIDGET_TYPE_ARROW,
950  LIVES_WIDGET_TYPE_RULER,
951  LIVES_WIDGET_TYPE_COMBO,
952  LIVES_WIDGET_TYPE_TABLE,
953  LIVES_WIDGET_TYPE_DIALOG,
954  LIVES_WIDGET_TYPE_MESSAGE_DIALOG,
955  LIVES_WIDGET_TYPE_ALIGNMENT,
956  LIVES_WIDGET_TYPE_IMAGE,
957  LIVES_WIDGET_TYPE_LABEL,
958  LIVES_WIDGET_TYPE_NOTEBOOK,
959  LIVES_WIDGET_TYPE_TREE_VIEW,
960  LIVES_WIDGET_TYPE_HSEPARATOR,
961  LIVES_WIDGET_TYPE_VSEPARATOR,
962  LIVES_WIDGET_TYPE_MAIN_WINDOW,
963  LIVES_WIDGET_TYPE_SUB_WINDOW,
964  LIVES_WIDGET_TYPE_EVENT_BOX,
965  LIVES_WIDGET_TYPE_DRAWING_AREA,
966  LIVES_WIDGET_TYPE_HBOX,
967  LIVES_WIDGET_TYPE_VBOX,
968 } LiVESWidgetObjectType;
969 
970 
971 LIVES_INLINE QKeySequence make_qkey_sequence(uint32_t key, LiVESXModifierType mods) {
972  return static_cast<Qt::Key>(key) | mods;
973 }
974 
975 LIVES_INLINE uint32_t qkeysequence_get_key(QKeySequence ks) {
976  return ks[0] & 0x01FFFFFF;
977 }
978 
979 
980 LIVES_INLINE LiVESXModifierType qkeysequence_get_mod(QKeySequence ks) {
981  return static_cast<LiVESXModifierType>(ks[0] & 0xF2000000);
982 }
983 
984 
985 class evFilter : public QObject {
986 public:
987 
988 protected:
989  bool eventFilter(QObject *obj, QEvent *event);
990 
991 };
992 
993 
994 #ifdef HAVE_X11
995 
996 class nevfilter : public QAbstractNativeEventFilter {
997 public:
998 
999  virtual bool nativeEventFilter(const QByteArray &eventType, livespointer message, long *);
1000 
1001 };
1002 
1003 #endif
1004 
1005 class LiVESWidgetObject : public QWidget {
1006  Q_OBJECT
1007 
1008 public:
1009 
1010  void block_signal(ulong handler_id);
1011  void block_signals(const char *signame);
1012  void block_signals(ulong func, livespointer data);
1013  void unblock_signal(ulong handler_id);
1014  void unblock_signals(const char *signame);
1015  void unblock_signals(ulong func, livespointer data);
1016  void disconnect_signal(ulong handler_id);
1017 
1018  void add_accel(LiVESAccel *accel);
1019  void add_accel(ulong handler_id, const char *signal_name, ulong funcptr, livespointer data);
1020  void add_accel(const char *signal_name, LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mod, LiVESAccelFlags flags);
1021 
1022  boolean remove_accel(LiVESAccel *accel);
1023  boolean remove_accels(LiVESAccelGroup *, uint32_t key, LiVESXModifierType mod);
1024 
1025  boolean remove_accel_group(LiVESAccelGroup *group);
1026  void add_accel_group(LiVESAccelGroup *group);
1027 
1028  QList<LiVESAccelGroup *> get_accel_groups();
1029 
1030  QList<LiVESAccel *> get_accels_for(LiVESAccelGroup *group, QKeySequence ks);
1031  QList<LiVESAccel *> get_accels_for(ulong func, livespointer data);
1032  QList<LiVESAccel *> get_accels_for(const char *signame);
1033  LiVESAccel *get_accel_for(ulong handler_id);
1034 
1035  boolean activate_accel(uint32_t key, LiVESXModifierType mod);
1036  boolean activate_accel(QKeySequence ks);
1037 
1038  void remove_all_accels();
1039 
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 
1078 private:
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 
1107 typedef struct LiVESList LiVESList;
1108 
1109 struct LiVESList {
1110  livesconstpointer data;
1111  LiVESList *prev;
1112  LiVESList *next;
1113 };
1114 
1115 
1116 typedef struct LiVESSList LiVESSList;
1117 
1118 struct LiVESSList {
1119  livesconstpointer data;
1120  LiVESSList *next;
1121 };
1122 
1123 typedef LiVESList LiVESDList;
1124 
1125 
1126 LIVES_INLINE livesconstpointer lives_list_nth_data(LiVESList *list, uint32_t n) {
1127  for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1128  if (list == NULL) return NULL;
1129  livesconstpointer data = list->data;
1130  return data;
1131 }
1132 
1133 LIVES_INLINE LiVESList *lives_list_nth(LiVESList *list, uint32_t n) {
1134  for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1135  return list;
1136 }
1137 
1138 LIVES_INLINE livesconstpointer lives_slist_nth_data(LiVESSList *list, uint32_t n) {
1139  for (unsigned int i = 0; i < n && list != NULL; i++) list = list->next;
1140  if (list == NULL) return NULL;
1141  livesconstpointer data = list->data;
1142  return data;
1143 }
1144 
1145 LIVES_INLINE int lives_list_length(LiVESList *list) {
1146  int i;
1147  for (i = 0; list != NULL; i++) list = list->next;
1148  return i;
1149 }
1150 
1151 LIVES_INLINE int lives_slist_length(LiVESSList *list) {
1152  int i;
1153  for (i = 0; list != NULL; i++) list = list->next;
1154  return i;
1155 }
1156 
1157 
1158 
1159 LIVES_INLINE LiVESList *lives_list_remove(LiVESList *list, livesconstpointer data) {
1160  LiVESList *olist = list;
1161  for (int i = 0; list->data != data && list != NULL; i++) list = list->next;
1162  if (list == NULL) return NULL;
1163  if (list->prev != NULL) list->prev->next = list->next;
1164  else olist = list->next;
1165  if (list->next != NULL) list->next->prev = list->prev;
1166 
1167  list->next = list->prev = NULL;
1168 
1169  return olist;
1170 }
1171 
1172 
1173 LIVES_INLINE LiVESList *lives_list_remove_link(LiVESList *olist, LiVESList *list) {
1174  if (olist == NULL) return NULL;
1175 
1176  if (list->prev != NULL) list->prev->next = list->next;
1177  else olist = list->next;
1178  if (list->next != NULL) list->next->prev = list->prev;
1179 
1180  list->next = list->prev = NULL;
1181 
1182  return olist;
1183 }
1184 
1185 
1186 LIVES_INLINE LiVESSList *lives_slist_remove(LiVESSList *list, livesconstpointer data) {
1187  LiVESSList *olist = list, *xlist = list;
1188  for (int i = 0; list->data != data && list != NULL; i++) {
1189  xlist = list;
1190  list = list->next;
1191  }
1192  if (list == NULL) return NULL;
1193 
1194  xlist->next = list->next;
1195 
1196  if (list == olist) olist = list->next;
1197 
1198  list->next = NULL;
1199 
1200  return olist;
1201 }
1202 
1203 
1204 LIVES_INLINE LiVESList *lives_list_append(LiVESList *list, livesconstpointer data) {
1205  LiVESList *olist = NULL, *xlist = list;
1206 
1207  while (list != NULL) {
1208  olist = list;
1209  list = list->next;
1210  }
1211 
1212  LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1213  elem->data = data;
1214  elem->next = NULL;
1215  elem->prev = olist;
1216 
1217  if (olist == NULL) xlist = elem;
1218  return xlist;
1219 }
1220 
1221 
1222 LIVES_INLINE LiVESSList *lives_slist_append(LiVESSList *list, livesconstpointer data) {
1223  LiVESSList *olist = NULL, *xlist = list;
1224 
1225  while (list != NULL) {
1226  olist = list;
1227  list = list->next;
1228  }
1229 
1230  LiVESSList *elem = (LiVESSList *)malloc(sizeof(LiVESSList));
1231  elem->data = data;
1232  elem->next = NULL;
1233 
1234  if (olist == NULL) xlist = elem;
1235  return xlist;
1236 }
1237 
1238 
1239 LIVES_INLINE LiVESList *lives_list_prepend(LiVESList *list, livesconstpointer data) {
1240  LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1241  elem->data = data;
1242  elem->next = list;
1243  elem->prev = NULL;
1244  return elem;
1245 }
1246 
1247 
1248 LIVES_INLINE LiVESSList *lives_slist_prepend(LiVESSList *list, livesconstpointer data) {
1249  LiVESSList *elem = (LiVESSList *)malloc(sizeof(LiVESSList));
1250  elem->data = data;
1251  elem->next = list;
1252  return elem;
1253 }
1254 
1255 
1256 LIVES_INLINE LiVESList *lives_list_insert(LiVESList *list, livespointer data, int pos) {
1257  if (pos == 0) return lives_list_prepend(list, data);
1258 
1259  LiVESList *xlist = list, *olist = NULL;
1260 
1261  while (list != NULL && pos != 0) {
1262  olist = list;
1263  list = list->next;
1264  pos--;
1265  }
1266 
1267  LiVESList *elem = (LiVESList *)malloc(sizeof(LiVESList));
1268  elem->data = data;
1269  elem->next = olist->next;
1270  olist->next = elem;
1271  if (elem->next != NULL) elem->next->prev = elem;
1272  elem->prev = olist;
1273 
1274  if (xlist == NULL) xlist = elem;
1275  return xlist;
1276 
1277 }
1278 
1279 
1280 
1281 LIVES_INLINE LiVESList *lives_list_find(LiVESList *list, livesconstpointer data) {
1282  while (list != NULL) {
1283  if (list->data == data) return list;
1284  list = list->next;
1285  }
1286  return NULL;
1287 }
1288 
1289 
1290 LIVES_INLINE LiVESList *lives_list_find_custom(LiVESList *list, livesconstpointer data, LiVESCompareFunc func) {
1291  while (list != NULL) {
1292  if (! func(list->data, data))
1293  return list;
1294  list = list->next;
1295  }
1296  return NULL;
1297 }
1298 
1299 
1300 
1301 LIVES_INLINE void lives_list_free(LiVESList *list) {
1302  LiVESList *nlist;
1303  while (list != NULL) {
1304  nlist = list->next;
1305  free(list);
1306  list = nlist;
1307  }
1308 }
1309 
1310 
1311 LIVES_INLINE void lives_slist_free(LiVESSList *list) {
1312  LiVESSList *nlist;
1313  while (list != NULL) {
1314  nlist = list->next;
1315  free(list);
1316  list = nlist;
1317  }
1318 }
1319 
1320 
1321 LIVES_INLINE LiVESList *lives_list_previous(LiVESList *list) {
1322  if (list == NULL) return NULL;
1323  return list->prev;
1324 }
1325 
1326 
1327 LIVES_INLINE LiVESList *lives_list_last(LiVESList *list) {
1328  if (list == NULL) return NULL;
1329  while (list->next != NULL) list = list->next;
1330  return list;
1331 }
1332 
1333 
1334 
1335 LIVES_INLINE LiVESList *lives_list_delete_link(LiVESList *list, LiVESList *link) {
1336  list = lives_list_remove_link(list, link);
1337  free(link);
1338  return list;
1339 }
1340 
1341 
1342 LIVES_INLINE LiVESList *lives_list_copy(LiVESList *list) {
1343  LiVESList *new_list = NULL;
1344  while (list != NULL) {
1345  lives_list_append(new_list, list->data);
1346  list = list->next;
1347  }
1348  return new_list;
1349 }
1350 
1351 
1352 LIVES_INLINE LiVESList *lives_list_concat(LiVESList *a, LiVESList *b) {
1353  LiVESList *xlist = lives_list_last(a);
1354  xlist->next = b;
1355  b->prev = xlist;
1356  return a;
1357 }
1358 
1359 
1360 
1361 char **lives_strsplit(const char *string, const char *delimiter, int max_tokens) {
1362  LiVESSList *string_list = NULL, *slist;
1363  char **str_array;
1364  const char *s;
1365  uint32_t n = 0;
1366  const char *remainder;
1367  if (max_tokens < 1)
1368  max_tokens = INT_MAX;
1369  remainder = string;
1370  s = strstr(remainder, delimiter);
1371  if (s) {
1372  size_t delimiter_len = strlen(delimiter);
1373  while (--max_tokens && s) {
1374  size_t len;
1375  len = s - remainder;
1376  string_list = lives_slist_prepend(string_list, lives_strndup(remainder, len));
1377  n++;
1378  remainder = s + delimiter_len;
1379  s = strstr(remainder, delimiter);
1380  }
1381  }
1382  if (*string) {
1383  n++;
1384  string_list = lives_slist_prepend(string_list, lives_strdup(remainder));
1385  }
1386  str_array = (char **)lives_malloc((n + 1) * sizeof(char *));
1387  str_array[n--] = NULL;
1388  for (slist = string_list; slist; slist = slist->next)
1389  str_array[n--] = (char *)slist->data;
1390  lives_slist_free(string_list);
1391  return str_array;
1392 }
1393 
1394 
1395 
1396 char *lives_strdelimit(char *string, const char *delimiters, char new_delim) {
1397  char *c;
1398  for (c = string; *c; c++) {
1399  if (strchr(delimiters, *c))
1400  *c = new_delim;
1401  }
1402  return string;
1403 }
1404 
1405 
1406 
1407 
1408 char *lives_strstr_len(const char *haystack, ssize_t haystack_len, const char *needle) {
1409  if (haystack_len < 0)
1410  return (char *)strstr(haystack, needle);
1411  else {
1412  const char *p = haystack;
1413  size_t needle_len = strlen(needle);
1414  const char *end;
1415  size_t i;
1416  if (needle_len == 0)
1417  return (char *)haystack;
1418  if (haystack_len < needle_len)
1419  return NULL;
1420  end = haystack + haystack_len - needle_len;
1421  while (p <= end && *p) {
1422  for (i = 0; i < needle_len; i++)
1423  if (p[i] != needle[i])
1424  goto next;
1425  return (char *)p;
1426 next:
1427  p++;
1428  }
1429  return NULL;
1430  }
1431 }
1432 
1433 
1434 
1435 #define ICON_SCALE(a) ((int)(1.0 * a))
1436 typedef QSize LiVESIconSize;
1437 #define LIVES_ICON_SIZE_INVALID QSize(0,0)
1438 #define LIVES_ICON_SIZE_MENU QSize(ICON_SCALE(16),ICON_SCALE(16))
1439 #define LIVES_ICON_SIZE_SMALL_TOOLBAR QSize(ICON_SCALE(16),ICON_SCALE(16))
1440 #define LIVES_ICON_SIZE_LARGE_TOOLBAR QSize(ICON_SCALE(24),ICON_SCALE(24))
1441 #define LIVES_ICON_SIZE_BUTTON QSize(ICON_SCALE(16),ICON_SCALE(16))
1442 #define LIVES_ICON_SIZE_DND QSize(ICON_SCALE(32),ICON_SCALE(32))
1443 #define LIVES_ICON_SIZE_DIALOG QSize(ICON_SCALE(48),ICON_SCALE(48))
1444 
1445 
1446 typedef Qt::TransformationMode LiVESInterpType;
1447 #define LIVES_INTERP_BEST Qt::SmoothTransformation
1448 #define LIVES_INTERP_NORMAL Qt::SmoothTransformation
1449 #define LIVES_INTERP_FAST Qt::FastTransformation
1450 
1451 typedef int LiVESResponseType;
1452 #define LIVES_RESPONSE_NONE QDialogButtonBox::InvalidRole
1453 #define LIVES_RESPONSE_OK QDialogButtonBox::AcceptRole
1454 #define LIVES_RESPONSE_CANCEL QDialogButtonBox::RejectRole
1455 
1456 #define LIVES_RESPONSE_ACCEPT QDialogButtonBox::AcceptRole
1457 
1458 #define LIVES_RESPONSE_YES QDialogButtonBox::YesRole
1459 #define LIVES_RESPONSE_NO QDialogButtonBox::NoRole
1460 
1461 #define LIVES_RESPONSE_INVALID QDialogButtonBox::InvalidRole
1462 #define LIVES_RESPONSE_SHOW_DETAILS 100
1463 
1464 #define LIVES_RESPONSE_RETRY 101
1465 #define LIVES_RESPONSE_ABORT 102
1466 #define LIVES_RESPONSE_RESET 103
1467 
1468 typedef QStyle::StandardPixmap LiVESArrowType;
1469 #define LIVES_ARROW_UP QStyle::SP_ArrowUp
1470 #define LIVES_ARROW_DOWN QStyle::SP_ArrowDown
1471 #define LIVES_ARROW_LEFT QStyle::SP_ArrowLeft
1472 #define LIVES_ARROW_RIGHT QStyle::SP_ArrowRight
1473 #define LIVES_ARROW_NONE -1
1474 
1475 class LiVESWidget : public LiVESWidgetObject {
1476  Q_OBJECT
1477 
1478 public:
1479 
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 
1632 public 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 
1675 private:
1676  LiVESList *children;
1677  LiVESWidget *parent;
1678  QString widgetName;
1679 
1680  LiVESWidgetColor *fg_norm, *bg_norm, *base_norm, *text_norm;
1681  LiVESWidgetColor *fg_act, *bg_act, *base_act, *text_act;
1682  LiVESWidgetColor *fg_insen, *bg_insen, *base_insen, *text_insen;
1683  LiVESWidgetColor *fg_hover, *bg_hover, *base_hover, *text_hover;
1684  LiVESWidgetColor *fg_sel, *bg_sel, *base_sel, *text_sel;
1685 
1686  LiVESWidgetState state;
1687 
1688  uint32_t events_mask;
1689  uint32_t onetime_events_mask;
1690 
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 
1743 bool evFilter::eventFilter(QObject *obj, QEvent *event) {
1744 
1745  // TODO - add motion-notify-event, leave-notify-event, button-release-event, focus_out_event
1746 
1747  // event->accept() to block ?
1748 
1749  // return true to block ?
1750 
1751  switch (event->type()) {
1752 
1753  case (QEvent::Shortcut): {
1754  QShortcutEvent *qevent = static_cast<QShortcutEvent *>(event);
1755  QKeySequence ks = qevent->key();
1756  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1757  object->activate_accel(ks);
1758  return false;
1759  }
1760 
1761  case (QEvent::Wheel): {
1762  QWheelEvent *qevent = static_cast<QWheelEvent *>(event);
1763  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1764  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1765  if (!(widget->get_events() & LIVES_SCROLL_MASK)) return true;
1766  if (!(widget->get_onetime_events_block() & LIVES_SCROLL_MASK)) {
1767  widget->remove_onetime_event_block(LIVES_SCROLL_MASK);
1768  event->accept();
1769  return true;
1770  }
1771  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_SCROLL_EVENT);
1772  LiVESXEventScroll *scrollevent = NULL;
1773  if (qevent->angleDelta().y() > 0) scrollevent->direction = LIVES_SCROLL_UP;
1774  else scrollevent->direction = LIVES_SCROLL_DOWN;
1775 
1776  scrollevent->state = QApplication::queryKeyboardModifiers();
1777 
1778  for (int i = 0; i < accels.size(); i++) {
1779  LiVESScrollEventCallback *cb = (LiVESScrollEventCallback *)accels[i]->closure->function;
1780  bool ret = (*cb)(widget, scrollevent, accels[i]->closure->data);
1781  if (ret) return true;
1782  }
1783  }
1784 
1785  case (QEvent::Paint): {
1786  QPaintEvent *qevent = static_cast<QPaintEvent *>(event);
1787  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1788  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1789  if (!(widget->get_events() & LIVES_EXPOSURE_MASK)) return true;
1790  if (!(widget->get_onetime_events_block() & LIVES_EXPOSURE_MASK)) {
1791  widget->remove_onetime_event_block(LIVES_EXPOSURE_MASK);
1792  event->accept();
1793  return true;
1794  }
1795  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_EXPOSE_EVENT);
1796  LiVESXEventExpose *exposeevent = NULL;
1797  QRect qr = qevent->rect();
1798  exposeevent->area.x = qr.x();
1799  exposeevent->area.y = qr.y();
1800  exposeevent->area.width = qr.width();
1801  exposeevent->area.height = qr.height();
1802 
1803  exposeevent->count = 0;
1804 
1805  for (int i = 0; i < accels.size(); i++) {
1806  LiVESExposeEventCallback *cb = (LiVESExposeEventCallback *)accels[i]->closure->function;
1807  bool ret = (*cb)(widget, exposeevent, accels[i]->closure->data);
1808  if (ret) return true;
1809  }
1810  }
1811 
1812  case (QEvent::Enter): {
1813  //QEnterEvent *qevent = static_cast<QEnterEvent *>(event);
1814  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1815  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1816  if (!(widget->get_events() & LIVES_ENTER_NOTIFY_MASK)) return true;
1817  if (!(widget->get_onetime_events_block() & LIVES_ENTER_NOTIFY_MASK)) {
1818  widget->remove_onetime_event_block(LIVES_ENTER_NOTIFY_MASK);
1819  event->accept();
1820  return true;
1821  }
1822  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_ENTER_EVENT);
1823  LiVESXEventCrossing *crossingevent = NULL;
1824 
1825  for (int i = 0; i < accels.size(); i++) {
1826  LiVESEnterEventCallback *cb = (LiVESEnterEventCallback *)accels[i]->closure->function;
1827  bool ret = (*cb)(widget, crossingevent, accels[i]->closure->data);
1828  if (ret) return true;
1829  }
1830  }
1831 
1832  case (QEvent::MouseButtonPress): {
1833  QMouseEvent *qevent = static_cast<QMouseEvent *>(event);
1834  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1835  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1836  if (!(widget->get_events() & LIVES_BUTTON_PRESS_MASK)) return true;
1837  if (!(widget->get_onetime_events_block() & LIVES_BUTTON_PRESS_MASK)) {
1838  widget->remove_onetime_event_block(LIVES_BUTTON_PRESS_MASK);
1839  event->accept();
1840  return true;
1841  }
1842  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_BUTTON_PRESS_EVENT);
1843 
1844  LiVESXEventButton *buttonevent = NULL;
1845  if (qevent->button() == Qt::LeftButton) buttonevent->button = 1;
1846  if (qevent->button() == Qt::MidButton) buttonevent->button = 2;
1847  if (qevent->button() == Qt::RightButton) buttonevent->button = 3;
1848 
1849  buttonevent->type = LIVES_BUTTON_PRESS;
1850  buttonevent->time = qtime->elapsed();
1851 
1852  for (int i = 0; i < accels.size(); i++) {
1853  LiVESButtonEventCallback *cb = (LiVESButtonEventCallback *)accels[i]->closure->function;
1854  bool ret = (*cb)(widget, buttonevent, accels[i]->closure->data);
1855  if (ret) return true;
1856  }
1857  }
1858 
1859  case (QEvent::MouseButtonDblClick): {
1860  QMouseEvent *qevent = static_cast<QMouseEvent *>(event);
1861  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1862  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1863  if (!(widget->get_events() & LIVES_BUTTON_PRESS_MASK)) return true;
1864  if (!(widget->get_onetime_events_block() & LIVES_BUTTON_PRESS_MASK)) {
1865  widget->remove_onetime_event_block(LIVES_BUTTON_PRESS_MASK);
1866  event->accept();
1867  return true;
1868  }
1869  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_BUTTON_PRESS_EVENT);
1870 
1871  LiVESXEventButton *buttonevent = NULL;
1872  if (qevent->button() == Qt::LeftButton) buttonevent->button = 1;
1873  if (qevent->button() == Qt::MidButton) buttonevent->button = 2;
1874  if (qevent->button() == Qt::RightButton) buttonevent->button = 3;
1875 
1876  buttonevent->type = LIVES_BUTTON2_PRESS;
1877 
1878  for (int i = 0; i < accels.size(); i++) {
1879  LiVESButtonEventCallback *cb = (LiVESButtonEventCallback *)accels[i]->closure->function;
1880  bool ret = (*cb)(widget, buttonevent, accels[i]->closure->data);
1881  if (ret) return true;
1882  }
1883  }
1884 
1885  case (QEvent::Resize): {
1886  //QShowEvent *qevent = static_cast<QResizeEvent *>(event);
1887  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1888  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1889  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_CONFIGURE_EVENT);
1890  LiVESXEventConfigure *configureevent = NULL;
1891 
1892  for (int i = 0; i < accels.size(); i++) {
1893  LiVESConfigureEventCallback *cb = (LiVESConfigureEventCallback *)accels[i]->closure->function;
1894  bool ret = (*cb)(widget, configureevent, accels[i]->closure->data);
1895  if (ret) return true;
1896  }
1897  }
1898 
1899  case (QEvent::Close): {
1900  //QCloseEvent *qevent = static_cast<QCloseEvent *>(event);
1901  LiVESWidgetObject *object = static_cast<LiVESWidgetObject *>(obj);
1902  LiVESWidget *widget = static_cast<LiVESWidget *>(object);
1903  QList<LiVESAccel *>accels = object->get_accels_for(LIVES_WIDGET_DELETE_EVENT);
1904  LiVESXEventDelete *deleteevent = NULL;
1905 
1906  for (int i = 0; i < accels.size(); i++) {
1907  LiVESDeleteEventCallback *cb = (LiVESDeleteEventCallback *)accels[i]->closure->function;
1908  bool ret = (*cb)(widget, deleteevent, accels[i]->closure->data);
1909  if (ret) return true;
1910  }
1911  }
1912 
1913  default:
1914  return false;
1915 
1916  }
1917 
1918  return false; // continue
1919 }
1920 
1921 
1922 
1923 
1924 void LiVESWidget::update_stylesheet() {
1925  QWidget *qw = static_cast<QWidget *>(this);
1926  QString stylesheet;
1927  QString col;
1928 
1929  stylesheet = "QWidget#" + widgetName + " {color: ";
1930  col = make_col(fg_norm);
1931  stylesheet += col;
1932  stylesheet += "; background-color: ";
1933  col = make_col(bg_norm);
1934  stylesheet += col;
1935  stylesheet += "; selection-background-color: ";
1936  col = make_col(bg_sel);
1937  stylesheet += col;
1938  stylesheet += "; selection-color: ";
1939  col = make_col(fg_sel);
1940  stylesheet += col;
1941  stylesheet += " } ";
1942  stylesheet = "QWidget#" + widgetName + ":active {color: ";
1943  col = make_col(fg_act);
1944  stylesheet += col;
1945  stylesheet += "; background-color: ";
1946  col = make_col(bg_act);
1947  stylesheet += col;
1948  stylesheet += " } ";
1949  stylesheet = "QWidget#" + widgetName + ":[prelight=true] {color: ";
1950  col = make_col(fg_hover);
1951  stylesheet += col;
1952  stylesheet += "; background-color: ";
1953  col = make_col(bg_hover);
1954  stylesheet += col;
1955  stylesheet += " } ";
1956  stylesheet = "QWidget#" + widgetName + ":hover {color: ";
1957  col = make_col(fg_hover);
1958  stylesheet += col;
1959  stylesheet += "; background-color: ";
1960  col = make_col(bg_hover);
1961  stylesheet += col;
1962  stylesheet += " } ";
1963  stylesheet = "QWidget#" + widgetName + ":disabled {color: ";
1964  col = make_col(fg_insen);
1965  stylesheet += col;
1966  stylesheet += "; background-color: ";
1967  col = make_col(bg_insen);
1968  stylesheet += col;
1969  stylesheet += " } ";
1970 
1971  qw->setStyleSheet(stylesheet);
1972  qw->update();
1973 }
1974 
1975 
1976 
1977 void LiVESWidget::set_fg_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
1978  switch (state) {
1979  case (LIVES_WIDGET_STATE_NORMAL):
1980  lives_widget_color_copy(fg_norm, col);
1981  break;
1982  case (LIVES_WIDGET_STATE_ACTIVE):
1983  lives_widget_color_copy(fg_act, col);
1984  break;
1985  case (LIVES_WIDGET_STATE_INSENSITIVE):
1986  lives_widget_color_copy(fg_insen, col);
1987  break;
1988  case (LIVES_WIDGET_STATE_PRELIGHT):
1989  lives_widget_color_copy(fg_hover, col);
1990  break;
1991  case (LIVES_WIDGET_STATE_SELECTED):
1992  lives_widget_color_copy(fg_sel, col);
1993  break;
1994  default:
1995  break;
1996  }
1997  update_stylesheet();
1998 }
1999 
2000 
2001 void LiVESWidget::set_bg_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2002  switch (state) {
2003  case (LIVES_WIDGET_STATE_NORMAL):
2004  lives_widget_color_copy(bg_norm, col);
2005  break;
2006  case (LIVES_WIDGET_STATE_ACTIVE):
2007  lives_widget_color_copy(bg_act, col);
2008  break;
2009  case (LIVES_WIDGET_STATE_INSENSITIVE):
2010  lives_widget_color_copy(bg_insen, col);
2011  break;
2012  case (LIVES_WIDGET_STATE_PRELIGHT):
2013  lives_widget_color_copy(bg_hover, col);
2014  break;
2015  case (LIVES_WIDGET_STATE_SELECTED):
2016  lives_widget_color_copy(bg_sel, col);
2017  break;
2018  default:
2019  break;
2020  }
2021  update_stylesheet();
2022 }
2023 
2024 
2025 void LiVESWidget::set_base_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2026  switch (state) {
2027  case (LIVES_WIDGET_STATE_NORMAL):
2028  lives_widget_color_copy(base_norm, col);
2029  break;
2030  case (LIVES_WIDGET_STATE_ACTIVE):
2031  lives_widget_color_copy(base_act, col);
2032  break;
2033  case (LIVES_WIDGET_STATE_INSENSITIVE):
2034  lives_widget_color_copy(base_insen, col);
2035  break;
2036  case (LIVES_WIDGET_STATE_PRELIGHT):
2037  lives_widget_color_copy(base_hover, col);
2038  break;
2039  case (LIVES_WIDGET_STATE_SELECTED):
2040  lives_widget_color_copy(base_sel, col);
2041  break;
2042  default:
2043  break;
2044  }
2045  update_stylesheet();
2046 }
2047 
2048 
2049 void LiVESWidget::set_text_color(LiVESWidgetState state, const LiVESWidgetColor *col) {
2050  switch (state) {
2051  case (LIVES_WIDGET_STATE_NORMAL):
2052  lives_widget_color_copy(text_norm, col);
2053  break;
2054  case (LIVES_WIDGET_STATE_ACTIVE):
2055  lives_widget_color_copy(text_act, col);
2056  break;
2057  case (LIVES_WIDGET_STATE_INSENSITIVE):
2058  lives_widget_color_copy(text_insen, col);
2059  break;
2060  case (LIVES_WIDGET_STATE_PRELIGHT):
2061  lives_widget_color_copy(text_hover, col);
2062  break;
2063  case (LIVES_WIDGET_STATE_SELECTED):
2064  lives_widget_color_copy(text_sel, col);
2065  break;
2066  default:
2067  break;
2068  }
2069  update_stylesheet();
2070 }
2071 
2072 
2073 LiVESWidgetColor *LiVESWidget::get_fg_color(LiVESWidgetState state) {
2074  switch (state) {
2075  case (LIVES_WIDGET_STATE_NORMAL):
2076  return fg_norm;
2077  break;
2078  case (LIVES_WIDGET_STATE_ACTIVE):
2079  return fg_act;
2080  break;
2081  case (LIVES_WIDGET_STATE_INSENSITIVE):
2082  return fg_insen;
2083  break;
2084  case (LIVES_WIDGET_STATE_PRELIGHT):
2085  return fg_hover;
2086  break;
2087  case (LIVES_WIDGET_STATE_SELECTED):
2088  return fg_sel;
2089  break;
2090  default:
2091  break;
2092  }
2093  return NULL;
2094 }
2095 
2096 
2097 LiVESWidgetColor *LiVESWidget::get_bg_color(LiVESWidgetState state) {
2098  switch (state) {
2099  case (LIVES_WIDGET_STATE_NORMAL):
2100  return bg_norm;
2101  break;
2102  case (LIVES_WIDGET_STATE_ACTIVE):
2103  return bg_act;
2104  break;
2105  case (LIVES_WIDGET_STATE_INSENSITIVE):
2106  return bg_insen;
2107  break;
2108  case (LIVES_WIDGET_STATE_PRELIGHT):
2109  return bg_hover;
2110  break;
2111  case (LIVES_WIDGET_STATE_SELECTED):
2112  return bg_sel;
2113  break;
2114  default:
2115  break;
2116  }
2117  return NULL;
2118 }
2119 
2120 
2121 ulong lives_signal_connect(LiVESWidgetObject *object, const char *signal_name, ulong funcptr, livespointer data) {
2122  ulong handler_id;
2123  handler_id = ulong_random();
2124 
2125  object->add_accel(handler_id, signal_name, funcptr, data);
2126 
2127  if (!strcmp(signal_name, LIVES_WIDGET_CLICKED_EVENT)) {
2128  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2129  SIGNAL(clicked()),
2130  static_cast<QObject *>(object),
2131  SLOT(cb_wrapper_clicked()));
2132  } else if (!strcmp(signal_name, LIVES_WIDGET_TOGGLED_EVENT)) {
2133  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2134  SIGNAL(toggled()),
2135  static_cast<QObject *>(object),
2136  SLOT(cb_wrapper_toggled()));
2137  } else if (!strcmp(signal_name, LIVES_WIDGET_CHANGED_EVENT)) {
2138  // for combo, entry, LiVESTreeSelection
2139  if (LIVES_IS_COMBO(object))
2140  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2141  SIGNAL(currentTextChanged()),
2142  static_cast<QObject *>(object),
2143  SLOT(cb_wrapper_changed()));
2144 
2145  else if (LIVES_IS_ENTRY(object))
2146  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2147  SIGNAL(textChanged()),
2148  static_cast<QObject *>(object),
2149  SLOT(cb_wrapper_changed()));
2150 
2151  else {
2152  QTreeWidget *qtw = dynamic_cast<QTreeWidget *>(object);
2153  if (qtw != NULL) {
2154  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2155  SIGNAL(itemSelectionChanged()),
2156  static_cast<QObject *>(object),
2157  SLOT(cb_wrapper_changed()));
2158 
2159  }
2160  }
2161  } else if (!strcmp(signal_name, LIVES_WIDGET_VALUE_CHANGED_EVENT)) {
2162  // for spinbutton, scrollbar
2163  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2164  SIGNAL(valueChanged()),
2165  static_cast<QObject *>(object),
2166  SLOT(cb_wrapper_value_changed()));
2167 
2168  } else if (!strcmp(signal_name, LIVES_WIDGET_SELECTION_CHANGED_EVENT)) {
2169  // for filedialog
2170  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2171  SIGNAL(currentChanged()),
2172  static_cast<QObject *>(object),
2173  SLOT(cb_wrapper_selection_changed()));
2174 
2175  } else if (!strcmp(signal_name, LIVES_WIDGET_CURRENT_FOLDER_CHANGED_EVENT)) {
2176  // for filedialog
2177  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2178  SIGNAL(currentUrlChanged()),
2179  static_cast<QObject *>(object),
2180  SLOT(cb_wrapper_current_folder_changed()));
2181 
2182  } else if (!strcmp(signal_name, LIVES_WIDGET_ACTIVATE_EVENT)) {
2183  // for menuitems (QAction)
2184  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2185  SIGNAL(triggered()),
2186  static_cast<QObject *>(object),
2187  SLOT(cb_wrapper_activate()));
2188 
2189  } else if (!strcmp(signal_name, LIVES_WIDGET_RESPONSE_EVENT)) {
2190  // for menuitems (QAction)
2191  (static_cast<QObject *>(object))->connect(static_cast<QObject *>(object),
2192  SIGNAL(finished()),
2193  static_cast<QObject *>(object),
2194  SLOT(cb_wrapper_response()));
2195 
2196  }
2197 
2198 
2199  return handler_id;
2200 }
2201 
2202 
2203 LIVES_INLINE void lives_widget_object_set_data(LiVESWidgetObject *widget, const char *prop, livespointer value) {
2204  QVariant v = qVariantFromValue((livespointer) value);
2205  widget->setProperty(prop, v);
2206 }
2207 
2208 
2209 LIVES_INLINE livespointer lives_widget_object_get_data(LiVESWidgetObject *widget, const char *prop) {
2210  QVariant v = widget->property(prop);
2211  return v.value<livespointer>();
2212 }
2213 
2214 
2215 
2216 
2217 #define lives_signal_connect_after(a,b,c,d) lives_signal_connect(a,b,c,d)
2218 
2219 
2220 
2221 void LiVESWidgetObject::add_accel(LiVESAccel *accel) {
2222  accels.push_back(accel);
2223 
2224  //QShortcut *shortcut = new QShortcut(accel->ks, dynamic_cast<QWidget *>(this));
2225  //accel->shortcut = shortcut;
2226 }
2227 
2228 
2229 void LiVESWidgetObject::add_accel(ulong handler_id, const char *signal_name, ulong funcptr, livespointer data) {
2230  LiVESAccel *accel = new LiVESAccel;
2231  accel->handler_id = handler_id;
2232  accel->signal_name = strdup(signal_name);
2233  LiVESClosure *cl = new LiVESClosure;
2234  cl->function = funcptr;
2235  cl->data = data;
2236  accel->closure = cl;
2237  add_accel(accel);
2238 }
2239 
2240 
2241 void LiVESWidgetObject::add_accel(const char *signal_name, LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mod,
2242  LiVESAccelFlags flags) {
2243  LiVESAccel *accel = new LiVESAccel;
2244  accel->handler_id = 0;
2245  accel->signal_name = strdup(signal_name);
2246  accel->closure = NULL;
2247  accel->group = group;
2248  accel->ks = make_qkey_sequence(key, mod);
2249  accel->flags = flags;
2250  add_accel(accel);
2251 }
2252 
2253 
2254 boolean LiVESWidgetObject::remove_accel(LiVESAccel *accel) {
2255  QList<LiVESAccel *>::iterator it = accels.begin();
2256 
2257  while (it != accels.end()) {
2258  if (((LiVESAccel *)*it) == accel) {
2259  delete accel->shortcut;
2260  delete accel->signal_name;
2261  delete accel->closure;
2262  accels.erase(it);
2263  return TRUE;
2264  } else
2265  ++it;
2266  }
2267 
2268  return FALSE;
2269 }
2270 
2271 
2272 boolean LiVESWidgetObject::activate_accel(uint32_t key, LiVESXModifierType mod) {
2273  return activate_accel(make_qkey_sequence(key, mod));
2274 }
2275 
2276 
2277 boolean LiVESWidgetObject::activate_accel(QKeySequence ks) {
2278  for (int j = 0; j < accel_groups.size(); j++) {
2279  QList<LiVESAccel *> ql = get_accels_for(accel_groups.at(j), ks);
2280  for (int i = 0; i < ql.size(); i++) {
2281  LiVESAccel *accel = ql.at(i);
2282  if (accel->closure != NULL) {
2283  LiVESAccelCallback *cb = (LiVESAccelCallback *)accel->closure->function;
2284  uint32_t key = qkeysequence_get_key(ks);
2285  LiVESXModifierType mod = qkeysequence_get_mod(ks);
2286  (*cb)(accel->group, this, key, mod, accel->closure->data);
2287  } else {
2288  if (!strcmp(accel->signal_name, LIVES_WIDGET_CLICKED_EVENT)) {
2289  QAbstractButton *widget = dynamic_cast<QAbstractButton *>(this);
2290  if (widget != NULL) widget->click();
2291  }
2292 
2293  if (!strcmp(accel->signal_name, LIVES_WIDGET_TOGGLED_EVENT)) {
2294  QAbstractButton *widget = dynamic_cast<QAbstractButton *>(this);
2295  if (widget != NULL) widget->toggle();
2296  }
2297 
2298  }
2299  return TRUE;
2300  }
2301  }
2302  return FALSE;
2303 }
2304 
2305 
2306 
2307 void LiVESWidgetObject::remove_all_accels() {
2308  QList<LiVESAccel *>::iterator it = accels.begin();
2309  while (it != accels.end()) {
2310  remove_accel((LiVESAccel *)*it);
2311  }
2312 }
2313 
2314 
2315 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(ulong func, livespointer data) {
2316  QList<LiVESAccel *> ql;
2317  for (int i = 0; i < accels.size(); i++) {
2318  if (accels[i]->closure == NULL) continue;
2319  if (accels[i]->closure->function == func && accels[i]->closure->data == data) ql.push_back(accels[i]);
2320  }
2321  return ql;
2322 }
2323 
2324 
2325 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(const char *signame) {
2326  QList<LiVESAccel *> ql;
2327  for (int i = 0; i < accels.size(); i++) {
2328  if (accels[i]->signal_name == signame) ql.push_back(accels[i]);
2329  }
2330  return ql;
2331 }
2332 
2333 
2334 LiVESAccel *LiVESWidgetObject::get_accel_for(ulong handler_id) {
2335  for (int i = 0; i < accels.size(); i++) {
2336  if (accels[i]->handler_id == handler_id) {
2337  return accels[i];
2338  }
2339  }
2340  return NULL;
2341 }
2342 
2343 
2344 void LiVESWidgetObject::block_signal(ulong handler_id) {
2345  LiVESAccel *accel = get_accel_for(handler_id);
2346  accel->blocked = true;
2347 }
2348 
2349 
2350 void LiVESWidgetObject::block_signals(const char *signame) {
2351  QList<LiVESAccel *>ql = get_accels_for(signame);
2352  for (int i = 0; i < ql.size(); i++) {
2353  ql[i]->blocked = true;
2354  }
2355 }
2356 
2357 void LiVESWidgetObject::block_signals(ulong func, livespointer data) {
2358  QList<LiVESAccel *>ql = get_accels_for(func, data);
2359  for (int i = 0; i < ql.size(); i++) {
2360  ql[i]->blocked = true;
2361  }
2362 }
2363 
2364 
2365 void LiVESWidgetObject::unblock_signal(ulong handler_id) {
2366  LiVESAccel *accel = get_accel_for(handler_id);
2367  accel->blocked = false;
2368 }
2369 
2370 
2371 void LiVESWidgetObject::unblock_signals(const char *signame) {
2372  QList<LiVESAccel *>ql = get_accels_for(signame);
2373  for (int i = 0; i < ql.size(); i++) {
2374  ql[i]->blocked = false;
2375  }
2376 }
2377 
2378 
2379 void LiVESWidgetObject::unblock_signals(ulong func, livespointer data) {
2380  QList<LiVESAccel *>ql = get_accels_for(func, data);
2381  for (int i = 0; i < ql.size(); i++) {
2382  ql[i]->blocked = false;
2383  }
2384 }
2385 
2386 
2387 void LiVESWidgetObject::disconnect_signal(ulong handler_id) {
2388  LiVESAccel *accel = get_accel_for(handler_id);
2389  remove_accel(accel);
2390 }
2391 
2392 
2393 QList<LiVESAccelGroup *> LiVESWidgetObject::get_accel_groups() {
2394  return accel_groups;
2395 }
2396 
2397 
2398 
2399 class LiVESBox : public LiVESWidget {};
2400 
2401 
2402 class LiVESHBox : public LiVESBox, public QHBoxLayout {
2403 public:
2404  LiVESHBox() {
2405  set_type(LIVES_WIDGET_TYPE_HBOX);
2406  }
2407 };
2408 
2409 
2410 class LiVESEventBox : public LiVESBox, public QHBoxLayout {
2411 public:
2412  LiVESEventBox() {
2413  set_type(LIVES_WIDGET_TYPE_EVENT_BOX);
2414  }
2415 };
2416 
2417 
2418 class LiVESDrawingArea : public LiVESBox, public QHBoxLayout {
2419 public:
2420  LiVESDrawingArea() {
2421  set_type(LIVES_WIDGET_TYPE_DRAWING_AREA);
2422  }
2423 };
2424 
2425 
2426 class LiVESVBox : public LiVESBox, public QVBoxLayout {
2427 public:
2428  LiVESVBox() {
2429  set_type(LIVES_WIDGET_TYPE_VBOX);
2430  }
2431 };
2432 
2433 
2434 typedef class LiVESRange LiVESRange;
2435 
2436 class LiVESAdjustment : public LiVESWidgetObject {
2437 
2438 public:
2439 
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 
2494 private:
2495  double value;
2496  double lower;
2497  double upper;
2498  double step_increment;
2499  double page_increment;
2500  double page_size;
2501  boolean frozen;
2502 
2503  LiVESWidget *owner;
2504 
2505 };
2506 
2507 
2508 LIVES_INLINE QString qmake_mnemonic(QString qlabel) {
2509  qlabel = qlabel.replace('&', "&&");
2510  qlabel = qlabel.replace('_', '&');
2511  return qlabel;
2512 }
2513 
2514 
2515 LIVES_INLINE QString qmake_underline(QString qlabel) {
2516  qlabel = qlabel.replace('&', '_');
2517  qlabel = qlabel.replace("__", "&");
2518  return qlabel;
2519 }
2520 
2521 
2522 class LiVESButtonBase : public LiVESWidget {
2523 public:
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 
2549 private:
2550  bool use_underline;
2551 
2552  void init() {
2553  use_underline = false;
2554  }
2555 
2556 };
2557 
2558 
2559 
2560 class LiVESToggleButton : public LiVESButtonBase, public QCheckBox {};
2561 
2562 
2563 
2564 
2565 class LiVESButton : public LiVESButtonBase, public QPushButton {
2566 public:
2567 
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 
2586 private:
2587  LiVESWidget *layout;
2588  void init() {
2589  set_type(LIVES_WIDGET_TYPE_BUTTON);
2590  }
2591 
2592 };
2593 
2594 
2595 
2596 
2597 class LiVESSpinButton : public LiVESButtonBase, public QDoubleSpinBox {
2598 public:
2599 
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 
2624 private:
2625  LiVESAdjustment *adj;
2626 
2627  void init() {
2628  set_type(LIVES_WIDGET_TYPE_SPIN_BUTTON);
2629  }
2630 
2631 };
2632 
2633 
2634 
2635 
2636 class LiVESRadioButton : public LiVESButtonBase, public QRadioButton {
2637 public:
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 
2661 private:
2662  LiVESSList *slist;
2663 
2664  void init() {
2665  //setCheckable(true);
2666  set_type(LIVES_WIDGET_TYPE_RADIO_BUTTON);
2667  }
2668 
2669 };
2670 
2671 
2672 
2673 class LiVESCheckButton : public LiVESToggleButton {
2674 public:
2675 
2676  LiVESCheckButton() {
2677  init();
2678  }
2679 
2680  LiVESCheckButton(QString qs) {
2681  init();
2682  }
2683 
2684 private:
2685  void init() {
2686  set_type(LIVES_WIDGET_TYPE_CHECK_BUTTON);
2687  }
2688 
2689 };
2690 
2691 
2692 
2693 class LiVESButtonBox : public LiVESWidget, public QDialogButtonBox {
2694 public:
2695  LiVESButtonBox() {
2696  set_type(LIVES_WIDGET_TYPE_BUTTON_BOX);
2697  }
2698 
2699 };
2700 
2701 
2702 
2703 class LiVESMenuBar : public LiVESWidget, public QMenuBar {
2704 public:
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 
2739 class LiVESMenu : public LiVESWidget, public QMenu {
2740 public:
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 
2770 class LiVESTornOffMenu : public LiVESMenu {
2771 public:
2772  LiVESTornOffMenu(LiVESMenu *menu) {
2773  QWidget *qmenu = static_cast<QWidget *>(static_cast<QMenu *>(menu));
2774  QWidget *parentWidget = qmenu->parentWidget();
2775  QWidget *qwidget = (static_cast<QWidget *>(static_cast<QMenu *>(this)));
2776  qwidget->setParent(parentWidget, Qt::Window | Qt::Tool);
2777  qwidget->setAttribute(Qt::WA_DeleteOnClose, true);
2778  qwidget->setAttribute(Qt::WA_X11NetWmWindowTypeMenu, true);
2779  qwidget->setWindowTitle(qmenu->windowTitle());
2780  qwidget->setEnabled(qmenu->isEnabled());
2781 
2782  QList<QAction *> items = qmenu->actions();
2783  for (int i = 0; i < items.count(); i++)
2784  qwidget->addAction(items.at(i));
2785 
2786  set_parent(menu->get_parent());
2787 
2788  if (qmenu->isVisible()) {
2789  qmenu->hide();
2790  qwidget->setVisible(true);
2791  }
2792 
2793  }
2794 };
2795 
2796 
2797 
2798 
2799 
2800 class LiVESMenuItem : public LiVESWidget, public QAction {
2801 public:
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 
2818 class LiVESToolItem : public LiVESWidget, public QHBoxLayout {
2819 public:
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 
2834 private:
2835  LiVESWidget *layout;
2836 
2837  void init() {
2838  set_type(LIVES_WIDGET_TYPE_TOOL_ITEM);
2839  }
2840 };
2841 
2842 
2843 
2844 
2845 typedef LiVESMenuItem LiVESImageMenuItem;
2846 
2847 
2848 
2849 class LiVESMenuToolButton : public LiVESToolItem, public QWidgetAction {
2850 public:
2851 
2852  LiVESMenuToolButton(const QString &text, LiVESWidget *parent, LiVESWidget *icon) :
2853  QWidgetAction(static_cast<QObject *>(static_cast<LiVESWidgetObject *>(parent))) {
2854  QPushButton *qbutton = new QPushButton(text);
2855  set_type(LIVES_WIDGET_TYPE_MENU_TOOL_BUTTON);
2856  setDefaultWidget(qbutton);
2857  //setIcon(qicon);
2858  }
2859 
2860 };
2861 
2862 
2863 
2864 
2865 class LiVESCheckMenuItem : public LiVESWidget, public QAction {
2866 public:
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 
2875 private:
2876  void init() {
2877  set_type(LIVES_WIDGET_TYPE_CHECK_MENU_ITEM);
2878  setCheckable(true);
2879  }
2880 
2881 
2882 };
2883 
2884 
2885 class LiVESRadioMenuItem : public LiVESMenuItem {
2886 public:
2887 
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 
2913 private:
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 
2925 class LiVESCombo : public LiVESWidget, public QComboBox {
2926 public:
2927  LiVESCombo() {
2928  set_type(LIVES_WIDGET_TYPE_COMBO);
2929  }
2930 };
2931 
2932 
2933 class LiVESHSeparator : public LiVESWidget, public QHBoxLayout {
2934 public:
2935  LiVESHSeparator() {
2936  QFrame *line = new QFrame();
2937  line->setFrameShape(QFrame::HLine);
2938  line->setFrameShadow(QFrame::Sunken);
2939  addWidget(line);
2940  set_type(LIVES_WIDGET_TYPE_HSEPARATOR);
2941  }
2942 };
2943 
2944 
2945 
2946 class LiVESVSeparator : public LiVESWidget, public QVBoxLayout {
2947 public:
2948  LiVESVSeparator() {
2949  QFrame *line = new QFrame();
2950  line->setFrameShape(QFrame::VLine);
2951  line->setFrameShadow(QFrame::Sunken);
2952  addWidget(line);
2953  set_type(LIVES_WIDGET_TYPE_VSEPARATOR);
2954  }
2955 };
2956 
2957 
2958 
2959 class LiVESTextBuffer : public LiVESWidget, public QTextDocument {
2960 public:
2961 
2962  LiVESTextBuffer() {
2963  insert = QTextCursor(this);
2964  }
2965 
2966  QTextCursor get_cursor() {
2967  return insert;
2968  }
2969 
2970 private:
2971  QTextCursor insert;
2972 
2973 };
2974 
2975 
2976 
2977 class LiVESTextView : public LiVESWidget, public QTextEdit {
2978 public:
2979 
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 
2999 private:
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 
3012 class LiVESTextMark : public LiVESWidgetObject, public QTextCursor {
3013 public:
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 
3028 private:
3029  const char *name;
3030  boolean lgrav;
3031 
3032 };
3033 
3034 
3035 
3036 class LiVESRange : public LiVESWidget {
3037  Q_OBJECT
3038 
3039 public:
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 
3050 public slots:
3051  void valueChanged(int value) {
3052  adj->freeze();
3053  adj->set_value(value);
3054  adj->thaw();
3055  }
3056 
3057 private:
3058  LiVESAdjustment *adj;
3059 
3060 };
3061 
3062 
3063 class LiVESScale : public LiVESRange, public QSlider {
3064  // TODO - add a label
3065 public:
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 
3081 class LiVESScrollbar : public LiVESRange, public QScrollBar {
3082 public:
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 
3098 typedef LiVESScrollbar LiVESHScrollbar;
3099 
3100 
3101 class LiVESEntry : public LiVESWidget, public QLineEdit {
3102 public:
3103  LiVESEntry() {
3104  set_type(LIVES_WIDGET_TYPE_ENTRY);
3105  }
3106 };
3107 
3108 
3109 class LiVESProgressBar : public LiVESWidget, public QProgressBar {
3110 public:
3111  LiVESProgressBar() {
3112  set_type(LIVES_WIDGET_TYPE_PROGRESS_BAR);
3113  }
3114 };
3115 
3116 
3117 class LiVESPaned : public LiVESWidget, public QSplitter {
3118 public:
3119 
3120  LiVESPaned() {
3121  set_type(LIVES_WIDGET_TYPE_PANED);
3122  }
3123 };
3124 
3125 
3126 class LiVESLabel : public LiVESWidget, public QLabel {
3127 public:
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 
3154 private:
3155  LiVESWidget *mnemonicw;
3156  LiVESWidget *owner; // TODO
3157 };
3158 
3159 
3160 class LiVESRuler : public LiVESWidget, public QSlider {
3161 public:
3162  LiVESRuler() {
3163  set_type(LIVES_WIDGET_TYPE_RULER);
3164  }
3165 };
3166 
3167 
3168 
3169 
3170 class LiVESScrolledWindow : public LiVESWidget, public QScrollArea {
3171 public:
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 
3201 private:
3202  LiVESAdjustment *hadj;
3203  LiVESAdjustment *vadj;
3204 
3205 };
3206 
3207 
3208 
3209 
3210 
3211 class LiVESToolButton : public LiVESToolItem, public QToolButton {
3212 public:
3213 
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 
3278 private:
3279  bool use_underline;
3280 
3281  void init() {
3282  use_underline = false;
3283  }
3284 
3285 private:
3286  LiVESWidget *icon_widget;
3287  LiVESLabel *label_widget;
3288  LiVESVBox *layout;
3289 
3290 };
3291 
3292 
3293 
3294 
3295 
3296 
3297 
3298 typedef class LiVESWindow LiVESWindow;
3299 
3300 class LiVESAccelGroup {
3301 public:
3302  void add_all_accelerators(LiVESWidgetObject *window);
3303  void add_widget(LiVESWidgetObject *window);
3304  void remove_all_accelerators(LiVESWidgetObject *window);
3305  void remove_widget(LiVESWidgetObject *window);
3306 
3307  void connect(uint32_t key, LiVESXModifierType mod, LiVESAccelFlags flags, LiVESWidgetClosure *closure);
3308  void disconnect(LiVESWidgetClosure *closure);
3309 
3310  ~LiVESAccelGroup();
3311 
3312 private:
3313  QList<LiVESWidgetObject *>widgets;
3314  QList<LiVESAccel *>accels;
3315 
3316 
3317 };
3318 
3319 
3320 
3321 
3322 void LiVESWidgetObject::add_accel_group(LiVESAccelGroup *group) {
3323  accel_groups.push_back(group);
3324  group->add_all_accelerators(this);
3325  group->add_widget(this);
3326 }
3327 
3328 
3329 
3330 boolean LiVESWidgetObject::remove_accel_group(LiVESAccelGroup *group) {
3331  if (accel_groups.removeAll(group) > 0) {
3332  group->remove_all_accelerators(this);
3333  group->remove_widget(this);
3334  return TRUE;
3335  }
3336  return FALSE;
3337 }
3338 
3339 
3340 
3341 boolean LiVESWidgetObject::remove_accels(LiVESAccelGroup *group, uint32_t key, LiVESXModifierType mods) {
3342  bool ret = false;
3343  QKeySequence ks = make_qkey_sequence(key, mods);
3344 
3345  QList<LiVESAccel *>::iterator it = accels.begin();
3346  while (it != accels.end()) {
3347  if (((LiVESAccel *)*it)->group == group && ((LiVESAccel *)*it)->ks == ks) {
3348  remove_accel((LiVESAccel *)*it);
3349  ret = true;
3350  } else
3351  ++it;
3352  }
3353  return ret;
3354 }
3355 
3356 
3357 QList<LiVESAccel *> LiVESWidgetObject::get_accels_for(LiVESAccelGroup *group, QKeySequence ks) {
3358  QList<LiVESAccel *> ql;
3359  for (int i = 0; i < accels.size(); i++) {
3360  if (accels[i]->group == group && accels[i]->ks == ks) ql.push_back(accels[i]);
3361  }
3362  return ql;
3363 }
3364 
3365 
3366 
3367 class LiVESWindow : public LiVESWidget {};
3368 
3369 typedef int LiVESWindowPosition;
3370 #define LIVES_WIN_POS_DEFAULT 0
3371 #define LIVES_WIN_POS_CENTER_ALWAYS 1
3372 
3373 
3374 class LiVESMainWindow : public LiVESWindow, public QMainWindow {
3375 public:
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 
3400 private:
3401  LiVESWidget *layout;
3402  LiVESWindowPosition pos;
3403 
3404 };
3405 
3406 
3407 
3408 void LiVESAccelGroup::add_all_accelerators(LiVESWidgetObject *object) {
3409  for (int i = 0; i < accels.size(); i++) {
3410  object->add_accel(accels.at(i));
3411  }
3412 }
3413 
3414 void LiVESAccelGroup::add_widget(LiVESWidgetObject *window) {
3415  widgets.push_back(window);
3416 }
3417 
3418 
3419 void LiVESAccelGroup::remove_all_accelerators(LiVESWidgetObject *object) {
3420  while (accels.size() > 0) {
3421  object->remove_accel(accels.at(0));
3422  }
3423 }
3424 
3425 
3426 void LiVESAccelGroup::remove_widget(LiVESWidgetObject *window) {
3427  widgets.removeAll(window);
3428 }
3429 
3430 
3431 LiVESAccelGroup::~LiVESAccelGroup() {
3432  while (widgets.size() > 0) {
3433  remove_all_accelerators(widgets.at(0));
3434  }
3435 }
3436 
3437 
3438 class LiVESVLayout: public LiVESWidget, public QVBoxLayout {};
3439 
3440 class LiVESDialog : public LiVESWindow, public QDialog {
3441 public:
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 
3483 private:
3484  LiVESWidget *layout;
3485  LiVESWidget *contentArea;
3486  LiVESWidget *actionArea;
3487 };
3488 
3489 
3490 typedef int LiVESDialogFlags;
3491 typedef QMessageBox::Icon LiVESMessageType;
3492 
3493 #define LIVES_MESSAGE_INFO QMessageBox::Information
3494 #define LIVES_MESSAGE_WARNING QMessageBox::Warning
3495 #define LIVES_MESSAGE_QUESTION QMessageBox::Question
3496 #define LIVES_MESSAGE_ERROR QMessageBox::Warning
3497 #define LIVES_MESSAGE_OTHER QMessageBox::NoIcon
3498 
3499 typedef int LiVESButtonsType;
3500 #define LIVES_BUTTONS_NONE 0
3501 
3502 class LiVESMessageDialog : public LiVESWindow, public QMessageBox {
3503 public:
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 
3545 private:
3546  LiVESWidget *layout;
3547  LiVESWidget *contentArea;
3548  LiVESWidget *actionArea;
3549 };
3550 
3551 
3552 typedef void LiVESAboutDialog;
3553 
3554 
3555 class LiVESAlignment: public LiVESWidget, public QGridLayout {
3556 public:
3557  float xalign, yalign, xscale, yscale;
3558 
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 
3582 class LiVESImage : public LiVESWidget, public QImage {
3583 public:
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 
3602 private:
3603  void init() {
3604  set_type(LIVES_WIDGET_TYPE_IMAGE);
3605  }
3606 
3607 };
3608 
3609 
3610 
3611 
3612 class LiVESArrow : public LiVESImage {
3613 public:
3614  LiVESArrow(QImage *image) {
3615  set_type(LIVES_WIDGET_TYPE_ARROW);
3616  }
3617 };
3618 
3619 // rendertypes
3620 #define LIVES_CELL_RENDERER_TEXT 1
3621 #define LIVES_CELL_RENDERER_SPIN 2
3622 #define LIVES_CELL_RENDERER_TOGGLE 3
3623 #define LIVES_CELL_RENDERER_PIXBUF 4
3624 
3625 
3626 typedef struct {
3627  const char *attr;
3628  int col;
3629 } tvattrcol;
3630 
3631 typedef QHeaderView::ResizeMode LiVESTreeViewColumnSizing;
3632 
3633 #define LIVES_TREE_VIEW_COLUMN_GROW_ONLY QHeaderView::Stretch
3634 #define LIVES_TREE_VIEW_COLUMN_AUTOSIZE QHeaderView::ResizeToContents
3635 #define LIVES_TREE_VIEW_COLUMN_FIXED QHeaderView::Fixed
3636 
3637 typedef class LiVESTreeView LiVESTreeView;
3638 typedef LiVESTreeView LiVESTreeSelection;
3639 
3640 
3641 class LiVESTreeViewColumn : public LiVESWidgetObject, public QStyledItemDelegate {
3642  friend LiVESTreeView;
3643 
3644 public:
3645 
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 
3688 protected:
3689  int fwidth;
3690  int rendertype;
3691  LiVESTreeViewColumnSizing sizing;
3692  QList<tvattrcol *>attributes;
3693  const char *title;
3694  boolean expand;
3695 };
3696 
3697 
3698 typedef LiVESTreeViewColumn LiVESCellRenderer;
3699 
3700 
3701 typedef QAbstractItemView::SelectionMode LiVESSelectionMode;
3702 #define LIVES_SELECTION_NONE QAbstractItemView::NoSelection
3703 #define LIVES_SELECTION_SINGLE QAbstractItemView::SingleSelection
3704 #define LIVES_SELECTION_MULTIPLE QAbstractItemView::MultiSelection
3705 
3706 
3707 typedef class LiVESTreeStore LiVESTreeStore;
3708 
3709 
3710 class LiVESTreeModel : public LiVESWidgetObject, public QStandardItemModel {
3711  friend LiVESTreeStore;
3712 
3713 public:
3714 
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 
3729 protected:
3730  void set_coltypes(int ncols, int *types) {
3731  for (int i = 0; i < ncols; i++) {
3732  coltypes.append(types[i]);
3733  }
3734  }
3735 
3736 
3737 private:
3738  LiVESTreeView *widget;
3739  QList<int> coltypes;
3740 
3741 };
3742 
3743 
3744 typedef LiVESTreeModel LiVESListModel;
3745 
3746 
3747 class LiVESTreeView : public LiVESWidget, public QTreeWidget {
3748  //Q_OBJECT
3749 
3750 public:
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 
3847 private:
3848  LiVESTreeModel *model;
3849  LiVESAdjustment *hadj, *vadj;
3850 };
3851 
3852 
3853 #define LIVES_COL_TYPE_STRING 1
3854 #define LIVES_COL_TYPE_INT 2
3855 #define LIVES_COL_TYPE_UINT 3
3856 #define LIVES_COL_TYPE_BOOLEAN 4
3857 #define LIVES_COL_TYPE_PIXBUF 5
3858 
3859 
3860 typedef QTreeWidgetItem LiVESTreeIter;
3861 
3862 void LiVESTreeModel::set_tree_widget(LiVESTreeView *twidget) {
3863  widget = twidget;
3864 }
3865 
3866 QTreeWidget *LiVESTreeModel::get_qtree_widget() {
3867  return static_cast<QTreeWidget *>(widget);
3868 }
3869 
3870 
3871 
3872 class LiVESTreeStore : public LiVESTreeModel {
3873 public:
3874  LiVESTreeStore(int ncols, int *types) {}
3875 
3876 };
3877 
3878 
3879 class LiVESListStore : public LiVESListModel {
3880 public:
3881  LiVESListStore(int ncols, int *types) {}
3882 
3883 };
3884 
3885 
3886 
3887 
3888 
3889 void LiVESAdjustment::set_value(double newval) {
3890  if (newval != value) {
3891  value = newval;
3892 
3893  if (frozen) return;
3894 
3895  if (LIVES_IS_SCALE(owner)) {
3896  (dynamic_cast<QAbstractSlider *>(owner))->setValue(newval);
3897  } else if (LIVES_IS_SCROLLBAR(owner)) {
3898  (dynamic_cast<QScrollBar *>(owner))->setValue(newval);
3899  } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3900  //
3901  (dynamic_cast<QDoubleSpinBox *>(owner))->setValue(newval);
3902  } else if (LIVES_IS_TREE_VIEW(owner)) {
3903  if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3904  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setValue(newval);
3905  } else {
3906  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setValue(newval);
3907  }
3908  } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3909  if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3910  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setValue(newval);
3911  } else {
3912  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setValue(newval);
3913  }
3914  }
3915  }
3916 }
3917 
3918 
3919 void LiVESAdjustment::set_upper(double newval) {
3920  if (newval != upper) {
3921  upper = newval;
3922 
3923  if (frozen) return;
3924 
3925  if (LIVES_IS_SCALE(owner)) {
3926  (dynamic_cast<QAbstractSlider *>(owner))->setMaximum(newval);
3927  } else if (LIVES_IS_SCROLLBAR(owner)) {
3928  //
3929  (dynamic_cast<QScrollBar *>(owner))->setMaximum(newval);
3930  } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3931  //
3932  (dynamic_cast<QDoubleSpinBox *>(owner))->setMaximum(newval);
3933  } else if (LIVES_IS_TREE_VIEW(owner)) {
3934  if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3935  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMaximum(newval);
3936  } else {
3937  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMaximum(newval);
3938  }
3939  } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3940  if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3941  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMaximum(newval);
3942  } else {
3943  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMaximum(newval);
3944  }
3945  }
3946  }
3947 
3948 
3949 }
3950 
3951 
3952 
3953 void LiVESAdjustment::set_lower(double newval) {
3954  if (newval != lower) {
3955  lower = newval;
3956  if (frozen) return;
3957 
3958  if (LIVES_IS_SCALE(owner)) {
3959  (dynamic_cast<QAbstractSlider *>(owner))->setMinimum(newval);
3960  } else if (LIVES_IS_SCROLLBAR(owner)) {
3961  //
3962  (dynamic_cast<QScrollBar *>(owner))->setMinimum(newval);
3963  } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3964  //
3965  (dynamic_cast<QDoubleSpinBox *>(owner))->setMinimum(newval);
3966  } else if (LIVES_IS_TREE_VIEW(owner)) {
3967  if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
3968  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMinimum(newval);
3969  } else {
3970  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMinimum(newval);
3971  }
3972  } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
3973  if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
3974  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setMinimum(newval);
3975  } else {
3976  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setMinimum(newval);
3977  }
3978  }
3979  }
3980 }
3981 
3982 
3983 
3984 void LiVESAdjustment::set_step_increment(double newval) {
3985  if (newval != step_increment) {
3986  step_increment = newval;
3987 
3988  if (frozen) return;
3989 
3990  if (LIVES_IS_SCALE(owner)) {
3991  (dynamic_cast<QAbstractSlider *>(owner))->setSingleStep(newval);
3992  } else if (LIVES_IS_SCROLLBAR(owner)) {
3993  //
3994  (dynamic_cast<QScrollBar *>(owner))->setSingleStep(newval);
3995  } else if (LIVES_IS_SPIN_BUTTON(owner)) {
3996  //
3997  (dynamic_cast<QDoubleSpinBox *>(owner))->setSingleStep(newval);
3998  } else if (LIVES_IS_TREE_VIEW(owner)) {
3999  if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
4000  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setSingleStep(newval);
4001  } else {
4002  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setSingleStep(newval);
4003  }
4004  } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
4005  if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
4006  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setSingleStep(newval);
4007  } else {
4008  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setSingleStep(newval);
4009  }
4010  }
4011  }
4012 }
4013 
4014 
4015 void LiVESAdjustment::set_page_increment(double newval) {
4016  if (newval != page_increment) {
4017  page_increment = newval;
4018 
4019  if (frozen) return;
4020 
4021  if (LIVES_IS_SCALE(owner)) {
4022  (dynamic_cast<QAbstractSlider *>(owner))->setPageStep(newval);
4023  } else if (LIVES_IS_SCROLLBAR(owner)) {
4024  //
4025  (dynamic_cast<QScrollBar *>(owner))->setPageStep(newval);
4026  } else if (LIVES_IS_TREE_VIEW(owner)) {
4027  if (this == (dynamic_cast<LiVESTreeView *>(owner))->get_hadj()) {
4028  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setPageStep(newval);
4029  } else {
4030  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setPageStep(newval);
4031  }
4032  } else if (LIVES_IS_SCROLLED_WINDOW(owner)) {
4033  if (this == (dynamic_cast<LiVESScrolledWindow *>(owner))->get_hadj()) {
4034  (dynamic_cast<QAbstractScrollArea *>(owner))->horizontalScrollBar()->setPageStep(newval);
4035  } else {
4036  (dynamic_cast<QAbstractScrollArea *>(owner))->verticalScrollBar()->setPageStep(newval);
4037  }
4038  }
4039  }
4040 }
4041 
4042 
4043 void LiVESAdjustment::set_page_size(double newval) {
4044  // TODO
4045  if (newval != page_size) {
4046  page_size = newval;
4047 
4048  if (frozen) return;
4049  }
4050 }
4051 
4052 
4053 
4054 class LiVESTable : public LiVESWidget, public QGridLayout {
4055 
4056 public:
4057  LiVESTable() {
4058  set_type(LIVES_WIDGET_TYPE_TABLE);
4059  }
4060 
4061 
4062 private:
4063  LiVESWidget *layout;
4064 
4065 };
4066 
4067 
4068 typedef QWindow LiVESXWindow;
4069 
4070 typedef class LiVESImage LiVESPixbuf;
4071 
4072 typedef LiVESWidget LiVESEditable;
4073 typedef LiVESWidget LiVESContainer;
4074 typedef LiVESWidget LiVESMenuShell;
4075 typedef LiVESWidget LiVESBin;
4076 
4077 typedef QSlider LiVESScaleButton; // TODO - create
4078 typedef void LiVESExpander; // TODO - create
4079 
4080 
4081 void qt_jpeg_save(LiVESPixbuf *pixbuf, const char *fname, LiVESError **errptr, int quality) {
4082 #ifdef IS_MINGW
4083  QImageWriter qiw(QString::fromUtf8(fname), "jpeg");
4084 #else
4085  QImageWriter qiw(QString::fromLocal8Bit(fname), "jpeg");
4086 #endif
4087  qiw.setQuality(quality);
4088  if (!qiw.write(static_cast<QImage>(*pixbuf))) {
4089  if (errptr != NULL) {
4090  *errptr = (LiVESError *)malloc(sizeof(LiVESError));
4091  (*errptr)->code = qiw.error();
4092  (*errptr)->message = strdup(qiw.errorString().toUtf8().constData());
4093  }
4094  }
4095 }
4096 
4097 
4098 void qt_png_save(LiVESPixbuf *pixbuf, const char *fname, LiVESError **errptr, int cmp) {
4099 #ifdef IS_MINGW
4100  QImageWriter qiw(QString::fromUtf8(fname), "png");
4101 #else
4102  QImageWriter qiw(QString::fromLocal8Bit(fname), "png");
4103 #endif
4104  qiw.setCompression(cmp);
4105  if (!qiw.write(static_cast<QImage>(*pixbuf))) {
4106  if (errptr != NULL) {
4107  *errptr = (LiVESError *)malloc(sizeof(LiVESError));
4108  (*errptr)->code = qiw.error();
4109  (*errptr)->message = strdup(qiw.errorString().toUtf8().constData());
4110  }
4111  }
4112 }
4113 
4114 
4115 
4116 // scrolledwindow policies
4117 typedef Qt::ScrollBarPolicy LiVESPolicyType;
4118 #define LIVES_POLICY_AUTOMATIC Qt::ScrollBarAsNeeded
4119 #define LIVES_POLICY_NEVER Qt::ScrollBarAlwaysOff
4120 #define LIVES_POLICY_ALWAYS Qt::ScrollBarAlwaysOn
4121 
4122 
4123 class LiVESFrame : public LiVESWidget, public QGroupBox {
4124 public:
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 
4171 private:
4172  LiVESWidget *layout;
4173  LiVESLabel *label_widget;
4174 
4175 
4176 };
4177 
4178 
4179 class LiVESFileChooser : public LiVESWidget, public QFileDialog {
4180 public:
4181  LiVESFileChooser() {
4182  set_type(LIVES_WIDGET_TYPE_FILE_CHOOSER);
4183  }
4184 
4185 };
4186 
4187 
4188 typedef int LiVESFileChooserAction;
4189 #define LIVES_FILE_CHOOSER_ACTION_OPEN 1
4190 #define LIVES_FILE_CHOOSER_ACTION_SAVE 2
4191 #define LIVES_FILE_CHOOSER_ACTION_SELECT_FOLDER 3
4192 #define LIVES_FILE_CHOOSER_ACTION_CREATE_FOLDER 4
4193 #define LIVES_FILE_CHOOSER_ACTION_SELECT_DEVICE 5
4194 
4195 
4196 class LiVESNotebook : public LiVESWidget, public QTabWidget {
4197 public:
4198 
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 
4229 private:
4230  QList <LiVESWidget *> label_widgets;
4231 
4232 
4233 };
4234 
4235 
4236 
4237 class LiVESToolbar : public LiVESWidget, public QToolBar {
4238 public:
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 
4256 private:
4257  QList<QAction *>actions;
4258 
4259 
4260 };
4261 
4262 
4263 
4264 class LiVESColorButton : public LiVESButtonBase, public QPushButton {
4265  //Q_OBJECT
4266 
4267 public:
4268 
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 
4338 private:
4339  QColor colour;
4340  boolean use_alpha;
4341  QString title;
4342 };
4343 
4344 
4345 
4346 class LiVESTimer : public LiVESWidgetObject, public QTimer {
4347 public:
4348 
4349  LiVESTimer(uint32_t interval, LiVESWidgetSourceFunc xfunc, livespointer data);
4350 
4351  uint32_t get_handle() {
4352  return handle;
4353  }
4354 
4355  /* public slots:*/
4356 
4357  void update();
4358 
4359 
4360 private:
4361  uint32_t handle;
4362  LiVESWidgetSourceFunc func;
4363  livespointer data;
4364 
4365 };
4366 
4367 static QList<LiVESTimer *> static_timers;
4368 
4369 
4370 LiVESTimer::LiVESTimer(uint32_t interval, LiVESWidgetSourceFunc xfunc, livespointer data) {
4371  set_type(LIVES_OBJECT_TYPE_TIMER);
4372  static_timers.append(this);
4373 
4374  static_cast<QObject *>(static_cast<QTimer *>(this))->connect(static_cast<QObject *>(static_cast<QTimer *>(this)),
4375  SIGNAL(timeout()),
4376  static_cast<QObject *>(static_cast<QTimer *>(this)),
4377  SLOT(update()));
4378  start(interval);
4379 
4380 }
4381 
4382 
4383 void LiVESTimer::update() {
4384  // ret false to stop
4385  boolean ret = (func)(data);
4386  if (!ret) {
4387  stop();
4388  static_timers.removeOne(this);
4389  }
4390 }
4391 
4392 
4393 void remove_static_timer(uint32_t handle) {
4394  for (int i = 0; i < static_timers.size(); i++) {
4395  if (static_timers.at(i)->get_handle() == handle) {
4396  static_timers.removeOne(static_timers.at(i));
4397  break;
4398  }
4399  }
4400 }
4401 
4402 
4403 typedef Qt::ToolButtonStyle LiVESToolbarStyle;
4404 #define LIVES_TOOLBAR_ICONS Qt::ToolButtonIconOnly
4405 #define LIVES_TOOLBAR_TEXT Qt::ToolButtonTextOnly
4406 
4407 typedef QSize LiVESRequisition;
4408 
4409 typedef int LiVESTextIter;
4410 
4411 class LiVESTreePath {
4412 public:
4413 
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 
4444 private:
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 
4459 typedef Qt::Orientation LiVESOrientation;
4460 #define LIVES_ORIENTATION_HORIZONTAL Qt::Horizontal
4461 #define LIVES_ORIENTATION_VERTICAL Qt::Vertical
4462 
4463 typedef int LiVESButtonBoxStyle;
4464 #define LIVES_BUTTONBOX_DEFAULT_STYLE 0
4465 #define LIVES_BUTTONBOX_SPREAD 1
4466 #define LIVES_BUTTONBOX_EDGE 2
4467 #define LIVES_BUTTONBOX_START 3
4468 #define LIVES_BUTTONBOX_END 4
4469 #define LIVES_BUTTONBOX_CENTER 5
4470 
4471 typedef int LiVESReliefStyle;
4472 
4473 #define LIVES_RELIEF_NORMAL 2
4474 #define LIVES_RELIEF_HALF 1
4475 #define LIVES_RELIEF_NONE 0
4476 
4477 #define LIVES_ACCEL_VISIBLE 1
4478 
4479 typedef int LiVESWindowType;
4480 #define LIVES_WINDOW_TOPLEVEL Qt::Window
4481 #define LIVES_WINDOW_POPUP Qt::Popup
4482 
4483 typedef QFrame::Shadow LiVESShadowType;
4484 #define LIVES_SHADOW_NONE QFrame::Plain
4485 #define LIVES_SHADOW_IN QFrame::Raised
4486 #define LIVES_SHADOW_OUT QFrame::Sunken
4487 #define LIVES_SHADOW_ETCHED_IN QFrame::Raised
4488 #define LIVES_SHADOW_ETCHED_OUT QFrame::Sunken
4489 
4490 
4491 
4492 typedef int LiVESPositionType;
4493 #define LIVES_POS_LEFT 1
4494 #define LIVES_POS_RIGHT 2
4495 #define LIVES_POS_TOP 3
4496 #define LIVES_POS_BOTTOM 4
4497 
4498 
4499 #define LIVES_WIDGET(a) ((LiVESWidget *)a)
4500 
4501 
4502 #define LIVES_EDITABLE(a) (a)
4503 
4504 #define LIVES_CONTAINER(a) LIVES_WIDGET(a)
4505 #define LIVES_GUI_OBJECT(a) LIVES_WIDGET(a)
4506 #define LIVES_EXPANDER(a) LIVES_WIDGET(a)
4507 #define LIVES_BIN(a) LIVES_WIDGET(a)
4508 #define LIVES_MENU_SHELL(a) LIVES_WIDGET(a)
4509 
4510 #define LIVES_WIDGET_OBJECT(a) ((LiVESWidgetObject *)a)
4511 #define LIVES_COMBO(a) ((LiVESCombo *)a)
4512 #define LIVES_HBOX(a) ((LiVESHBox *)a)
4513 #define LIVES_VBOX(a) ((LiVESVBox *)a)
4514 #define LIVES_BOX(a) ((LiVESBox *)a)
4515 #define LIVES_ALIGNMENT(a) ((LiVESAlignment *)a)
4516 #define LIVES_TOOLBAR(a) ((LiVESToolbar *)a)
4517 #define LIVES_TOOL_BUTTON(a) ((LiVESToolButton *)a)
4518 #define LIVES_EVENT_BOX(a) ((LiVESEventBox *)a)
4519 #define LIVES_DRAWING_AREA(a) ((LiVESDrawingArea *)a)
4520 #define LIVES_TEXT_VIEW(a) ((LiVESTextView *)a)
4521 #define LIVES_TEXT_BUFFER(a) ((LiVESTextBuffer *)a)
4522 #define LIVES_BUTTON_BOX(a) ((LiVESButtonBox *)a)
4523 #define LIVES_FRAME(a) ((LiVESFrame *)a)
4524 #define LIVES_SCALE(a) ((LiVESScale *)a)
4525 #define LIVES_RANGE(a) ((LiVESRange *)a)
4526 #define LIVES_ADJUSTMENT(a) ((LiVESAdjustment *)a)
4527 #define LIVES_TABLE(a) ((LiVESTable *)a)
4528 #define LIVES_NOTEBOOK(a) ((LiVESNotebook *)a)
4529 #define LIVES_MENU(a) ((LiVESMenu *)a)
4530 #define LIVES_MENU_ITEM(a) ((LiVESMenuItem *)a)
4531 #define LIVES_MENU_TOOL_ITEM(a) ((LiVESMenuToolItem *)a)
4532 #define LIVES_MENU_TOOL_BUTTON(a) ((LiVESMenuToolButton *)a)
4533 #define LIVES_RULER(a) ((LiVESRuler *)a)
4534 #define LIVES_CHECK_MENU_ITEM(a) ((LiVESCheckMenuItem *)a)
4535 #define LIVES_IMAGE(a) ((LiVESImage *)a)
4536 #define LIVES_PROGRESS_BAR(a) ((LiVESProgressBar *)a)
4537 #define LIVES_BUTTON(a) ((LiVESButton *)a)
4538 #define LIVES_SPIN_BUTTON(a) ((LiVESSpinButton *)a)
4539 #define LIVES_SCALE_BUTTON(a) ((LiVESScaleButton *)a)
4540 #define LIVES_TOGGLE_BUTTON(a) ((LiVESToggleButton *)a)
4541 #define LIVES_RADIO_BUTTON(a) ((LiVESRadioButton *)a)
4542 #define LIVES_RADIO_MENU_ITEM(a) ((LiVESRadioMenuItem *)a)
4543 #define LIVES_COLOR_BUTTON(a) ((LiVESColorButton *)a)
4544 #define LIVES_DIALOG(a) ((LiVESDialog *)a)
4545 #define LIVES_LABEL(a) ((LiVESLabel *)a)
4546 #define LIVES_ENTRY(a) ((LiVESEntry *)a)
4547 #define LIVES_PANED(a) ((LiVESPaned *)a)
4548 #define LIVES_FILE_CHOOSER(a) ((LiVESFileChooser *)a)
4549 #define LIVES_ACCEL_GROUP(a) ((LiVESAccelGroup *)a)
4550 #define LIVES_WINDOW(a) ((LiVESWindow *)a)
4551 #define LIVES_SCROLLED_WINDOW(a) ((LiVESScrolledWindow *)a)
4552 #define LIVES_TREE_MODEL(a) ((LiVESTreeModel *)a)
4553 #define LIVES_TREE_VIEW(a) ((LiVESTreeView *)a)
4554 #define LIVES_LIST_STORE(a) ((LiVESListStore *)a)
4555 #define LIVES_TOOL_ITEM(a) ((LiVESToolItem *)a)
4556 
4557 
4558 #define LIVES_STOCK_UNDO "edit-undo"
4559 #define LIVES_STOCK_REDO "edit-redo"
4560 #define LIVES_STOCK_ADD "list-add"
4561 #define LIVES_STOCK_REMOVE "list-remove"
4562 #define LIVES_STOCK_NO "media-record"
4563 #define LIVES_STOCK_QUIT "application-exit"
4564 #define LIVES_STOCK_OPEN "document-open"
4565 #define LIVES_STOCK_CLOSE "window-close"
4566 #define LIVES_STOCK_CLEAR "edit-clear"
4567 #define LIVES_STOCK_DELETE "edit-delete"
4568 #define LIVES_STOCK_SAVE_AS "document-save-as"
4569 #define LIVES_STOCK_SAVE "document-save"
4570 #define LIVES_STOCK_REFRESH "view-refresh"
4571 #define LIVES_STOCK_REVERT_TO_SAVED "document-revert"
4572 #define LIVES_STOCK_GO_BACK "go-previous"
4573 #define LIVES_STOCK_GO_FORWARD "go-next"
4574 #define LIVES_STOCK_REFRESH "view-refresh"
4575 #define LIVES_STOCK_MEDIA_PLAY "media-playback-start"
4576 #define LIVES_STOCK_MEDIA_STOP "media-playback-stop"
4577 #define LIVES_STOCK_MEDIA_REWIND "media-seek-backward"
4578 #define LIVES_STOCK_MEDIA_RECORD "media-record"
4579 #define LIVES_STOCK_MEDIA_PAUSE "media-pause"
4580 #define LIVES_STOCK_PREFERENCES "preferences-system"
4581 #define LIVES_STOCK_DIALOG_INFO "dialog-information"
4582 #define LIVES_STOCK_MISSING_IMAGE "image-missing"
4583 
4584 
4585 #define LIVES_STOCK_YES "gtk-yes" // non-standard image ?
4586 #define LIVES_STOCK_APPLY "gtk-apply" // non-standard image ?
4587 #define LIVES_STOCK_CANCEL "gtk-cancel" // non-standard image ?
4588 #define LIVES_STOCK_OK "gtk-ok" // non-standard image ?
4589 
4590 
4591 char LIVES_STOCK_LABEL_CANCEL[32];
4592 char LIVES_STOCK_LABEL_OK[32];
4593 char LIVES_STOCK_LABEL_YES[32];
4594 char LIVES_STOCK_LABEL_NO[32];
4595 char LIVES_STOCK_LABEL_SAVE[32];
4596 char LIVES_STOCK_LABEL_SAVE_AS[32];
4597 char LIVES_STOCK_LABEL_OPEN[32];
4598 char LIVES_STOCK_LABEL_QUIT[32];
4599 char LIVES_STOCK_LABEL_APPLY[32];
4600 char LIVES_STOCK_LABEL_CLOSE[32];
4601 char LIVES_STOCK_LABEL_REVERT[32];
4602 char LIVES_STOCK_LABEL_REFRESH[32];
4603 char LIVES_STOCK_LABEL_DELETE[32];
4605 
4606 
4607 typedef int LiVESAttachOptions;
4608 #define LIVES_EXPAND 1
4609 #define LIVES_SHRINK 2
4610 #define LIVES_FILL 3
4611 
4612 
4613 //typedef int LiVESWrapMode;
4614 //#define LIVES_WRAP_NONE QTextEdit::NoWrap
4615 //#define LIVES_WRAP_WORD QTextEdit::WidgetWidth
4616 
4617 typedef bool LiVESWrapMode;
4618 #define LIVES_WRAP_NONE false
4619 #define LIVES_WRAP_WORD true
4620 
4621 typedef Qt::Alignment LiVESJustification;
4622 
4623 #define LIVES_JUSTIFY_LEFT Qt::AlignLeft
4624 #define LIVES_JUSTIFY_RIGHT Qt::AlignRight
4625 #define LIVES_JUSTIFY_CENTER Qt::AlignHCenter
4626 #define LIVES_JUSTIFY_FILL Qt::AlignJustify
4627 
4628 extern "C" {
4629  boolean lives_container_remove(LiVESContainer *, LiVESWidget *);
4630 }
4631 
4632 
4633 LiVESWidget::~LiVESWidget() {
4634  if (LIVES_IS_SPIN_BUTTON(this)) {
4635  LiVESAdjustment *adj = (static_cast<LiVESSpinButton *>(this))->get_adj();
4636  adj->dec_refcount();
4637  }
4638 
4639  if (LIVES_IS_RANGE(this)) {
4640  LiVESAdjustment *adj = (dynamic_cast<LiVESRange *>(this))->get_adj();
4641  adj->dec_refcount();
4642  }
4643 
4644  if (LIVES_IS_TREE_VIEW(this)) {
4645  LiVESAdjustment *adj = (static_cast<LiVESTreeView *>(this))->get_hadj();
4646  adj->dec_refcount();
4647  adj = (static_cast<LiVESTreeView *>(this))->get_vadj();
4648  adj->dec_refcount();
4649  }
4650 
4651  if (LIVES_IS_SCROLLED_WINDOW(this)) {
4652  LiVESAdjustment *adj = (static_cast<LiVESScrolledWindow *>(this))->get_hadj();
4653  adj->dec_refcount();
4654  adj = (static_cast<LiVESScrolledWindow *>(this))->get_vadj();
4655  adj->dec_refcount();
4656  }
4657 
4658  // remove from parents children
4659  if (parent != NULL) {
4660  inc_refcount();
4661  parent->remove_child(this);
4662  }
4663 
4664  LiVESList *xchildren = children;
4665 
4666  // decref all children
4667  while (xchildren != NULL) {
4668  lives_container_remove(this, (LiVESWidget *)xchildren->data);
4669  xchildren = xchildren->next;
4670  }
4671 
4672  lives_list_free(children);
4673 }
4674 
4675 #define LINGO_ALIGN_LEFT Qt::AlignLeft
4676 #define LINGO_ALIGN_RIGHT Qt::AlignRight
4677 #define LINGO_ALIGN_CENTER Qt::AlignHCenter
4678 
4679 #define LINGO_SCALE 1
4680 
4681 typedef class lives_painter_t lives_painter_t;
4682 
4683 class LingoLayout : public LiVESWidgetObject {
4684 public:
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 
4712 private:
4713  QString text;
4714  QFont font;
4715  int align;
4716  int x, y, width, height;
4717 };
4718 
4719 LIVES_INLINE void lingo_layout_set_alignment(LingoLayout *l, int alignment) {
4720  l->set_alignment(alignment);
4721 }
4722 
4723 
4724 LIVES_INLINE void lingo_layout_set_text(LingoLayout *l, const char *text, ssize_t len) {
4725  l->set_text(text, len);
4726 }
4727 
4728 
4729 LIVES_INLINE void lingo_layout_set_coords(LingoLayout *l, int x, int y, int width, int height) {
4730  l->set_coords(x, y, width, height);
4731 }
4732 
4733 
4734 LIVES_INLINE void lingo_layout_get_size(LingoLayout *l, int *rw, int *rh, int width, int height) {
4735  l->get_size(rw, rh, width, height);
4736 }
4737 
4738 
4739 LIVES_INLINE void lingo_painter_show_layout(lives_painter_t *painter, LingoLayout *l) {
4740  l->render_text(painter);
4741 }
4742 
4743 #endif
4744 
4745 
4746 
4747 #ifdef PAINTER_QPAINTER
4748 # include <QtGui/QPainter>
4749 
4750 //extern void lives_free(livespointer ptr);
4751 
4752 static void imclean(livespointer data) {
4753  lives_free(data);
4754 }
4755 
4756 typedef QImage::Format lives_painter_format_t;
4757 #define LIVES_PAINTER_FORMAT_A1 QImage::Format_Mono
4758 #define LIVES_PAINTER_FORMAT_A8 QImage::Format_Indexed8
4759 #define LIVES_PAINTER_FORMAT_ARGB32 QImage::Format_ARGB32_Premultiplied
4760 
4761 
4762 class lives_painter_surface_t : public QImage, public LiVESWidgetObject {
4763 public:
4764  int refcount;
4765 
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 
4778 boolean lives_painter_surface_destroy(lives_painter_surface_t *);
4779 
4780 
4781 class lives_painter_t : public QPainter {
4782 public:
4783  QPainterPath *p;
4784  lives_painter_surface_t *target;
4785  QPen pen;
4786 
4787 
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 
4805 private:
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 
4819 typedef QPainter::CompositionMode lives_painter_operator_t;
4820 
4821 #define LIVES_PAINTER_OPERATOR_UNKNOWN QPainter::CompositionMode_SourceOver
4822 #define LIVES_PAINTER_OPERATOR_DEFAULT QPainter::CompositionMode_SourceOver
4823 
4824 #define LIVES_PAINTER_OPERATOR_DEST_OUT QPainter::CompositionMode_DestinationOut
4825 
4826 #define LIVES_PAINTER_OPERATOR_DIFFERENCE QPainter::CompositionMode_Difference
4827 #define LIVES_PAINTER_OPERATOR_OVERLAY QPainter::CompositionMode_Overlay
4828 
4829 typedef Qt::FillRule lives_painter_fill_rule_t;
4830 
4831 #define LIVES_PAINTER_FILL_RULE_WINDING Qt::WindingFill
4832 #define LIVES_PAINTER_FILL_RULE_EVEN_ODD Qt::OddEvenFill
4833 
4834 
4835 #ifdef GUI_QT
4836 
4837 void LingoLayout::get_size(int *bwidth, int *bheight, int pwidth, int pheight) {
4838  QPainter qp;
4839  QRect rect = qp.boundingRect(0, 0, pwidth, pheight, Qt::AlignLeft | Qt::AlignTop, text);
4840  *bwidth = rect.width();
4841  *bheight = rect.height();
4842 }
4843 
4844 
4845 void LingoLayout::render_text(lives_painter_t *painter) {
4846  painter->drawText(x, y, width, height, align, text);
4847 }
4848 
4849 #endif
4850 
4851 
4852 #endif
4853 
4854 #include "moc_widget-helper-qt.cpp"
4855 
4856 
4857 #endif
lives_signal_connect
ulong lives_signal_connect(LiVESWidget *, const char *signal_name, ulong funcptr, livespointer data)
lives_free
#define lives_free
Definition: machinestate.h:52
LIVES_STOCK_LABEL_SAVE_AS
char LIVES_STOCK_LABEL_SAVE_AS[32]
Definition: widget-helper.h:1382
lives_malloc
#define lives_malloc
Definition: machinestate.h:46
lives_widget_color_copy
WIDGET_HELPER_GLOBAL_INLINE LiVESWidgetColor * lives_widget_color_copy(LiVESWidgetColor *c1, const LiVESWidgetColor *c2)
Definition: widget-helper.c:2258
lives_realloc
#define lives_realloc
Definition: machinestate.h:49
LIVES_STOCK_LABEL_REVERT
char LIVES_STOCK_LABEL_REVERT[32]
Definition: widget-helper.h:1387
LIVES_STOCK_LABEL_CLOSE
char LIVES_STOCK_LABEL_CLOSE[32]
Definition: widget-helper.h:1386
LIVES_STOCK_LABEL_QUIT
char LIVES_STOCK_LABEL_QUIT[32]
Definition: widget-helper.h:1384
LIVES_STOCK_LABEL_SAVE
char LIVES_STOCK_LABEL_SAVE[32]
Definition: widget-helper.h:1381
LIVES_STOCK_LABEL_DELETE
char LIVES_STOCK_LABEL_DELETE[32]
Definition: widget-helper.h:1389
LIVES_STOCK_LABEL_CANCEL
char LIVES_STOCK_LABEL_CANCEL[32]
stock labels, these are set up in widget_helper_init()
Definition: widget-helper.h:1377
lives_painter_surface_destroy
WIDGET_HELPER_GLOBAL_INLINE boolean lives_painter_surface_destroy(lives_painter_surface_t *surf)
Definition: widget-helper.c:457
TRUE
#define TRUE
Definition: videoplugin.h:59
support.h
LIVES_STOCK_LABEL_GO_FORWARD
char LIVES_STOCK_LABEL_GO_FORWARD[32]
Definition: widget-helper.h:1391
dgettext
#define dgettext(Domain, Message)
Definition: support.h:40
LIVES_STOCK_LABEL_APPLY
char LIVES_STOCK_LABEL_APPLY[32]
Definition: widget-helper.h:1385
translate_with_plural
LIVES_GLOBAL_INLINE char * translate_with_plural(const char *String, const char *StringPlural, unsigned long int n)
Definition: support.c:42
LIVES_STOCK_LABEL_NO
char LIVES_STOCK_LABEL_NO[32]
Definition: widget-helper.h:1380
dngettext
#define dngettext(Domain, Message, MsgPlur, n)
Definition: support.h:41
error
error("LSD_RANDFUNC(ptr, size) must be defined")
LIVES_STOCK_LABEL_OPEN
char LIVES_STOCK_LABEL_OPEN[32]
Definition: widget-helper.h:1383
lives_strdup_printf
#define lives_strdup_printf(fmt,...)
Definition: support.c:27
LIVES_STOCK_LABEL_YES
char LIVES_STOCK_LABEL_YES[32]
Definition: widget-helper.h:1379
lives_container_remove
WIDGET_HELPER_GLOBAL_INLINE boolean lives_container_remove(LiVESContainer *container, LiVESWidget *widget)
Definition: widget-helper.c:4938
lives_idle_add
WIDGET_HELPER_GLOBAL_INLINE uint32_t lives_idle_add(LiVESWidgetSourceFunc function, livespointer data)
Definition: widget-helper.c:7350
lives_timer_add
WIDGET_HELPER_GLOBAL_INLINE uint32_t lives_timer_add(uint32_t interval, LiVESWidgetSourceFunc function, livespointer data)
Definition: widget-helper.c:7318
ulong
#define ulong
Definition: main.h:178
LIVES_STOCK_LABEL_REFRESH
char LIVES_STOCK_LABEL_REFRESH[32]
Definition: widget-helper.h:1388
FALSE
#define FALSE
Definition: videoplugin.h:60
translate
LIVES_GLOBAL_INLINE char * translate(const char *String)
Definition: support.c:31
boolean
int boolean
Definition: videoplugin.h:54
LIVES_INLINE
#define LIVES_INLINE
Definition: main.h:238
LIVES_STOCK_LABEL_OK
char LIVES_STOCK_LABEL_OK[32]
Definition: widget-helper.h:1378