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