Mercurial > dwindows

comparison gtk/dw.c @ 14:176cee043f1b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Lots of Windows and Unix bug fixes.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Wed, 11 Jul 2001 21:57:56 +0000
parents 26e2130135b9
children 81833f25b1aa
comparison
equal deleted inserted replaced
13:156281539fb3 14:176cee043f1b
49 49
50 GdkColor _foreground = { 0, 0x0000, 0x0000, 0x0000 }; 50 GdkColor _foreground = { 0, 0x0000, 0x0000, 0x0000 };
51 GdkColor _background = { 0, 0xaaaa, 0xaaaa, 0xaaaa }; 51 GdkColor _background = { 0, 0xaaaa, 0xaaaa, 0xaaaa };
52 52
53 char *_dw_browse_file = NULL; 53 char *_dw_browse_file = NULL;
54 int _dw_file_active = 0, _dw_file_ready = 0; 54 int _dw_file_active = 0, _dw_file_ready = 0, _dw_ignore_click = 0;
55 pthread_t _dw_thread = (pthread_t)-1; 55 pthread_t _dw_thread = (pthread_t)-1;
56 int _dw_mutex_locked = FALSE; 56 int _dw_mutex_locked = FALSE;
57 57
58 #define DW_MUTEX_LOCK { if(pthread_self() != _dw_thread && _dw_mutex_locked == FALSE) { gdk_threads_enter(); _dw_mutex_locked = TRUE; _locked_by_me = TRUE; } } 58 #define DW_MUTEX_LOCK { if(pthread_self() != _dw_thread && _dw_mutex_locked == FALSE) { gdk_threads_enter(); _dw_mutex_locked = TRUE; _locked_by_me = TRUE; } }
59 #define DW_MUTEX_UNLOCK { if(pthread_self() != _dw_thread && _locked_by_me == TRUE) { gdk_threads_leave(); _dw_mutex_locked = FALSE; _locked_by_me = FALSE; } } 59 #define DW_MUTEX_UNLOCK { if(pthread_self() != _dw_thread && _locked_by_me == TRUE) { gdk_threads_leave(); _dw_mutex_locked = FALSE; _locked_by_me = FALSE; } }
60 60
61 /* Currently the non Imlib method does not work */ 61 /* Currently the non Imlib method does not work */
62 #ifndef USE_IMLIB 62 #ifndef USE_IMLIB
63 #define USE_IMLIB 63 #define USE_IMLIB
64 #endif 64 #endif
65
66 #define DEFAULT_SIZE_WIDTH 12
67 #define DEFAULT_SIZE_HEIGHT 6
68 #define DEFAULT_TITLEBAR_HEIGHT 22
65 69
66 GdkColormap *_dw_cmap = NULL; 70 GdkColormap *_dw_cmap = NULL;
67 71
68 /* Signal forwarder prototypes */ 72 /* Signal forwarder prototypes */
69 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 73 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
76 void _activate_event(GtkWidget *widget, gpointer data); 80 void _activate_event(GtkWidget *widget, gpointer data);
77 void _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 81 void _container_select_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
78 void _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data); 82 void _container_context_event(GtkWidget *widget, GdkEventButton *event, gpointer data);
79 void _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data); 83 void _item_select_event(GtkWidget *widget, GtkWidget *child, gpointer data);
80 void _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data); 84 void _expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data);
85 void _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data);
81 86
82 typedef struct 87 typedef struct
83 { 88 {
84 void *func; 89 void *func;
85 char name[30]; 90 char name[30];
92 void *func; 97 void *func;
93 gpointer data; 98 gpointer data;
94 99
95 } SignalHandler; 100 } SignalHandler;
96 101
97 #define SIGNALMAX 12 102 #define SIGNALMAX 13
98 103
99 /* A list of signal forwarders, to account for paramater differences. */ 104 /* A list of signal forwarders, to account for paramater differences. */
100 SignalList SignalTranslate[SIGNALMAX] = { 105 SignalList SignalTranslate[SIGNALMAX] = {
101 { _configure_event, "configure_event" }, 106 { _configure_event, "configure_event" },
102 { _key_press_event, "key_press_event" }, 107 { _key_press_event, "key_press_event" },
107 { _expose_event, "expose_event" }, 112 { _expose_event, "expose_event" },
108 { _activate_event, "activate" }, 113 { _activate_event, "activate" },
109 { _generic_event, "clicked" }, 114 { _generic_event, "clicked" },
110 { _container_select_event, "container-select" }, 115 { _container_select_event, "container-select" },
111 { _container_context_event, "container-context" }, 116 { _container_context_event, "container-context" },
112 { _item_select_event, "item-select" } 117 { _item_select_event, "item-select" },
118 { _set_focus_event, "set-focus" }
113 }; 119 };
114 120
115 /* Finds the translation function for a given signal name */ 121 /* Finds the translation function for a given signal name */
116 void *_findsigfunc(char *signame) 122 void *_findsigfunc(char *signame)
117 { 123 {
121 { 127 {
122 if(strcasecmp(signame, SignalTranslate[z].name) == 0) 128 if(strcasecmp(signame, SignalTranslate[z].name) == 0)
123 return SignalTranslate[z].func; 129 return SignalTranslate[z].func;
124 } 130 }
125 return NULL; 131 return NULL;
132 }
133
134 void _set_focus_event(GtkWindow *window, GtkWidget *widget, gpointer data)
135 {
136 SignalHandler *work = (SignalHandler *)data;
137
138 if(work)
139 {
140 int (*setfocusfunc)(HWND, void *) = work->func;
141
142 setfocusfunc((HWND)window, work->data);
143 }
126 } 144 }
127 145
128 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) 146 gint _button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
129 { 147 {
130 SignalHandler *work = (SignalHandler *)data; 148 SignalHandler *work = (SignalHandler *)data;
186 keys = DW_BUTTON1_MASK; 204 keys = DW_BUTTON1_MASK;
187 if (state & GDK_BUTTON3_MASK) 205 if (state & GDK_BUTTON3_MASK)
188 keys |= DW_BUTTON2_MASK; 206 keys |= DW_BUTTON2_MASK;
189 if (state & GDK_BUTTON2_MASK) 207 if (state & GDK_BUTTON2_MASK)
190 keys |= DW_BUTTON3_MASK; 208 keys |= DW_BUTTON3_MASK;
191 209
192 motionfunc(widget, x, y, keys, work->data); 210 motionfunc(widget, x, y, keys, work->data);
193 } 211 }
194 return TRUE; 212 return TRUE;
195 } 213 }
196 214
235 253
236 void _activate_event(GtkWidget *widget, gpointer data) 254 void _activate_event(GtkWidget *widget, gpointer data)
237 { 255 {
238 SignalHandler *work = (SignalHandler *)data; 256 SignalHandler *work = (SignalHandler *)data;
239 257
240 if(work) 258 if(work && !_dw_ignore_click)
241 { 259 {
242 void (*activatefunc)(HWND, void *) = work->func; 260 void (*activatefunc)(HWND, void *) = work->func;
243 261
244 activatefunc(work->window, work->data); 262 activatefunc(work->window, work->data);
245 } 263 }
427 * Initializes the Dynamic Windows engine. 445 * Initializes the Dynamic Windows engine.
428 * Parameters: 446 * Parameters:
429 * newthread: True if this is the only thread. 447 * newthread: True if this is the only thread.
430 * False if there is already a message loop running. 448 * False if there is already a message loop running.
431 */ 449 */
432 int dw_int_init(DWResources *res, int newthread) 450 int dw_int_init(DWResources *res, int newthread, int argc, char *argv[])
433 { 451 {
434 int z; 452 int z;
435 453
436 if(res) 454 if(res)
437 { 455 {
439 _resources.resource_id = res->resource_id; 457 _resources.resource_id = res->resource_id;
440 _resources.resource_data = res->resource_data; 458 _resources.resource_data = res->resource_data;
441 } 459 }
442 gtk_set_locale(); 460 gtk_set_locale();
443 g_thread_init(NULL); 461 g_thread_init(NULL);
444 gtk_init(0, NULL); 462
463 gtk_init(&argc, &argv);
445 #ifdef USE_IMLIB 464 #ifdef USE_IMLIB
446 gdk_imlib_init(); 465 gdk_imlib_init();
447 #endif 466 #endif
448 /* Add colors to the system colormap */ 467 /* Add colors to the system colormap */
449 _dw_cmap = gdk_colormap_get_system(); 468 _dw_cmap = gdk_colormap_get_system();
602 { 621 {
603 return FALSE; 622 return FALSE;
604 } 623 }
605 624
606 /* 625 /*
607 * Makes the window visible. 626 * Minimizes or Iconifies a top-level window.
608 * Parameters: 627 * Parameters:
609 * handle: The window handle to make visible. 628 * handle: The window handle to minimize.
610 */ 629 */
611 int dw_window_show(HWND handle) 630 int dw_window_minimize(HWND handle)
612 { 631 {
613 int _locked_by_me = FALSE; 632 int _locked_by_me = FALSE;
614 633
615 if(!handle) 634 if(!handle)
616 return 0; 635 return 0;
617 636
618 DW_MUTEX_LOCK; 637 DW_MUTEX_LOCK;
619 gtk_widget_show(handle); 638 XIconifyWindow(GDK_WINDOW_XDISPLAY(GTK_WIDGET(handle)->window),
639 GDK_WINDOW_XWINDOW(GTK_WIDGET(handle)->window),
640 DefaultScreen (GDK_DISPLAY ()));
620 DW_MUTEX_UNLOCK; 641 DW_MUTEX_UNLOCK;
621 return 0; 642 return 0;
622 } 643 }
623 644
624 /* 645 /*
625 * Makes the window invisible. 646 * Makes the window visible.
626 * Parameters: 647 * Parameters:
627 * handle: The window handle to make visible. 648 * handle: The window handle to make visible.
628 */ 649 */
629 int dw_window_hide(HWND handle) 650 int dw_window_show(HWND handle)
630 { 651 {
631 int _locked_by_me = FALSE; 652 int _locked_by_me = FALSE;
632 653
633 if(!handle) 654 if(!handle)
634 return 0; 655 return 0;
635 656
636 DW_MUTEX_LOCK; 657 DW_MUTEX_LOCK;
637 gtk_widget_hide(handle); 658 gtk_widget_show(handle);
659 gdk_window_raise(GTK_WIDGET(handle)->window);
660 gdk_flush();
661 gdk_window_show(GTK_WIDGET(handle)->window);
662 gdk_flush();
638 DW_MUTEX_UNLOCK; 663 DW_MUTEX_UNLOCK;
639 return 0; 664 return 0;
640 } 665 }
641 666
642 /* 667 /*
643 * Destroys a window and all of it's children. 668 * Makes the window invisible.
644 * Parameters: 669 * Parameters:
645 * handle: The window handle to destroy. 670 * handle: The window handle to make visible.
646 */ 671 */
647 int dw_window_destroy(HWND handle) 672 int dw_window_hide(HWND handle)
648 { 673 {
649 int _locked_by_me = FALSE; 674 int _locked_by_me = FALSE;
650 675
651 if(!handle) 676 if(!handle)
652 return 0; 677 return 0;
653 678
654 DW_MUTEX_LOCK; 679 DW_MUTEX_LOCK;
680 gtk_widget_hide(handle);
681 DW_MUTEX_UNLOCK;
682 return 0;
683 }
684
685 /*
686 * Destroys a window and all of it's children.
687 * Parameters:
688 * handle: The window handle to destroy.
689 */
690 int dw_window_destroy(HWND handle)
691 {
692 int _locked_by_me = FALSE;
693
694 if(!handle)
695 return 0;
696
697 DW_MUTEX_LOCK;
655 gtk_widget_destroy(handle); 698 gtk_widget_destroy(handle);
656 DW_MUTEX_UNLOCK; 699 DW_MUTEX_UNLOCK;
657 return 0; 700 return 0;
658 } 701 }
659 702
663 * handle: The window handle to destroy. 706 * handle: The window handle to destroy.
664 * newparent: The window's new parent window. 707 * newparent: The window's new parent window.
665 */ 708 */
666 void dw_window_reparent(HWND handle, HWND newparent) 709 void dw_window_reparent(HWND handle, HWND newparent)
667 { 710 {
668 gtk_widget_reparent(handle, newparent); 711 int _locked_by_me = FALSE;
712
713 DW_MUTEX_LOCK;
714 gdk_window_reparent(GTK_WIDGET(handle)->window, newparent ? GTK_WIDGET(newparent)->window : GDK_ROOT_PARENT(), 0, 0);
715 DW_MUTEX_UNLOCK;
669 } 716 }
670 717
671 int _set_font(HWND handle, char *fontname) 718 int _set_font(HWND handle, char *fontname)
672 { 719 {
673 GtkStyle *style; 720 GtkStyle *style;
717 764
718 DW_MUTEX_UNLOCK; 765 DW_MUTEX_UNLOCK;
719 return TRUE; 766 return TRUE;
720 } 767 }
721 768
769 void _free_gdk_colors(HWND handle)
770 {
771 GdkColor *old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "foregdk");
772
773 if(old)
774 free(old);
775
776 old = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "backgdk");
777
778 if(old)
779 free(old);
780 }
781
782 /* Free old color pointers and allocate new ones */
783 void _save_gdk_colors(HWND handle, GdkColor fore, GdkColor back)
784 {
785 GdkColor *foregdk = malloc(sizeof(GdkColor));
786 GdkColor *backgdk = malloc(sizeof(GdkColor));
787
788 _free_gdk_colors(handle);
789
790 *foregdk = fore;
791 *backgdk = back;
792
793 gtk_object_set_data(GTK_OBJECT(handle), "foregdk", (gpointer)foregdk);
794 gtk_object_set_data(GTK_OBJECT(handle), "backgdk", (gpointer)backgdk);
795 }
796
722 int _set_color(HWND handle, unsigned long fore, unsigned long back) 797 int _set_color(HWND handle, unsigned long fore, unsigned long back)
723 { 798 {
724 GtkStyle *style; 799 GtkStyle *style;
725 800
726 if(fore & DW_RGB_COLOR || back & DW_RGB_COLOR) 801 if(fore & DW_RGB_COLOR || back & DW_RGB_COLOR)
727 { 802 {
803 /* Remember that each color component in X11 use 16 bit no matter
804 * what the destination display supports. (and thus GDK)
805 */
728 GdkColor forecolor = { 0, DW_RED_VALUE(fore) << 8, DW_GREEN_VALUE(fore) << 8, DW_BLUE_VALUE(fore) << 8 }; 806 GdkColor forecolor = { 0, DW_RED_VALUE(fore) << 8, DW_GREEN_VALUE(fore) << 8, DW_BLUE_VALUE(fore) << 8 };
729 GdkColor backcolor = { 0, DW_RED_VALUE(back) << 8, DW_GREEN_VALUE(back) << 8, DW_BLUE_VALUE(back) << 8 }; 807 GdkColor backcolor = { 0, DW_RED_VALUE(back) << 8, DW_GREEN_VALUE(back) << 8, DW_BLUE_VALUE(back) << 8 };
730 808
731 gdk_color_alloc(_dw_cmap, &forecolor); 809 gdk_color_alloc(_dw_cmap, &forecolor);
732 gdk_color_alloc(_dw_cmap, &backcolor); 810 gdk_color_alloc(_dw_cmap, &backcolor);
733 811
734 style = gtk_widget_get_style(handle); 812 style = gtk_style_copy(gtk_widget_get_style(handle));
735 style->fg[1] = style->fg[0] = forecolor; 813 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = forecolor;
736 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = backcolor; 814 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = backcolor;
737 gtk_widget_set_style(handle, style); 815 gtk_widget_set_style(handle, style);
816
817 _save_gdk_colors(handle, forecolor, backcolor);
818
819 if(GTK_IS_CLIST(handle))
820 {
821 int z, rowcount = (int)gtk_object_get_data(GTK_OBJECT(handle), "rowcount");
822
823 for(z=0;z<rowcount;z++)
824 {
825 gtk_clist_set_foreground(GTK_CLIST(handle), z, &forecolor);
826 gtk_clist_set_background(GTK_CLIST(handle), z, &backcolor);
827 }
828 }
738 } 829 }
739 else 830 else
740 { 831 {
741 style = gtk_widget_get_style(handle); 832 style = gtk_style_copy(gtk_widget_get_style(handle));
742 style->fg[1] = style->fg[0] = _colors[fore]; 833 style->text[0] = style->text[1] = style->fg[0] = style->fg[1] = _colors[fore];
743 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = _colors[back]; 834 style->base[0] = style->base[1] = style->bg[0] = style->bg[1] = _colors[back];
744 gtk_widget_set_style(handle, style); 835 gtk_widget_set_style(handle, style);
836
837 _save_gdk_colors(handle, _colors[fore], _colors[back]);
838
839 if(GTK_IS_CLIST(handle))
840 {
841 int z, rowcount = (int)gtk_object_get_data(GTK_OBJECT(handle), "rowcount");
842
843 for(z=0;z<rowcount;z++)
844 {
845 gtk_clist_set_foreground(GTK_CLIST(handle), z, &_colors[fore]);
846 gtk_clist_set_background(GTK_CLIST(handle), z, &_colors[back]);
847 }
848 }
745 } 849 }
746 850
747 return TRUE; 851 return TRUE;
748 } 852 }
749 /* 853 /*
771 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "mle"); 875 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "mle");
772 if(tmp) 876 if(tmp)
773 handle2 = tmp; 877 handle2 = tmp;
774 } 878 }
775 879
776
777 gtk_object_set_data(GTK_OBJECT(handle2), "fore", (gpointer)fore);
778 gtk_object_set_data(GTK_OBJECT(handle2), "back", (gpointer)back);
779
780 _set_color(handle2, fore, back); 880 _set_color(handle2, fore, back);
781 881
782 DW_MUTEX_UNLOCK; 882 DW_MUTEX_UNLOCK;
783 return TRUE; 883 return TRUE;
784 } 884 }
830 */ 930 */
831 HWND dw_window_new(HWND hwndOwner, char *title, unsigned long flStyle) 931 HWND dw_window_new(HWND hwndOwner, char *title, unsigned long flStyle)
832 { 932 {
833 GtkWidget *tmp; 933 GtkWidget *tmp;
834 int _locked_by_me = FALSE; 934 int _locked_by_me = FALSE;
835 int flags = 0; 935 int flags = 0, cx = 0, cy = 0;
836 936
837 DW_MUTEX_LOCK; 937 DW_MUTEX_LOCK;
838 tmp = gtk_window_new(GTK_WINDOW_TOPLEVEL); 938 tmp = gtk_window_new(GTK_WINDOW_TOPLEVEL);
839 939
840 gtk_window_set_title(GTK_WINDOW(tmp), title); 940 gtk_window_set_title(GTK_WINDOW(tmp), title);
842 gtk_window_set_policy(GTK_WINDOW(tmp), FALSE, FALSE, TRUE); 942 gtk_window_set_policy(GTK_WINDOW(tmp), FALSE, FALSE, TRUE);
843 943
844 gtk_widget_realize(tmp); 944 gtk_widget_realize(tmp);
845 945
846 if(flStyle & DW_FCF_TITLEBAR) 946 if(flStyle & DW_FCF_TITLEBAR)
947 {
948 cy += DEFAULT_TITLEBAR_HEIGHT;
847 flags |= GDK_DECOR_TITLE; 949 flags |= GDK_DECOR_TITLE;
950 }
848 951
849 if(flStyle & DW_FCF_MINMAX) 952 if(flStyle & DW_FCF_MINMAX)
850 flags |= GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE; 953 flags |= GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE;
851 954
852 if(flStyle & DW_FCF_SIZEBORDER) 955 if(flStyle & DW_FCF_SIZEBORDER)
956 {
957 cy += DEFAULT_SIZE_HEIGHT;
958 cx += DEFAULT_SIZE_WIDTH;
853 flags |= GDK_DECOR_RESIZEH; 959 flags |= GDK_DECOR_RESIZEH;
960 }
854 961
855 if(flStyle & DW_FCF_BORDER) 962 if(flStyle & DW_FCF_BORDER)
856 flags |= GDK_DECOR_BORDER; 963 flags |= GDK_DECOR_BORDER;
857 964
858 gdk_window_set_decorations(tmp->window, flags); 965 gdk_window_set_decorations(tmp->window, flags);
966 gtk_object_set_data(GTK_OBJECT(tmp), "cx", (gpointer)cx);
967 gtk_object_set_data(GTK_OBJECT(tmp), "cy", (gpointer)cy);
968
969 if(hwndOwner)
970 gdk_window_reparent(GTK_WIDGET(tmp)->window, GTK_WIDGET(hwndOwner)->window, 0, 0);
859 971
860 DW_MUTEX_UNLOCK; 972 DW_MUTEX_UNLOCK;
861 return tmp; 973 return tmp;
862 } 974 }
863 975
890 * title: Text to be displayined in the group outline. 1002 * title: Text to be displayined in the group outline.
891 */ 1003 */
892 HWND dw_groupbox_new(int type, int pad, char *title) 1004 HWND dw_groupbox_new(int type, int pad, char *title)
893 { 1005 {
894 return dw_box_new(type, pad); 1006 return dw_box_new(type, pad);
1007 }
1008
1009 /*
1010 * Create a new MDI Frame to be packed.
1011 * Parameters:
1012 * id: An ID to be used with dw_window_from_id or 0L.
1013 */
1014 HWND dw_mdi_new(unsigned long id)
1015 {
1016 return gtk_vbox_new(FALSE, 0);
895 } 1017 }
896 1018
897 /* 1019 /*
898 * Create a bitmap object to be packed. 1020 * Create a bitmap object to be packed.
899 * Parameters: 1021 * Parameters:
1178 sprintf(numbuf, "%lu", id); 1300 sprintf(numbuf, "%lu", id);
1179 tmphandle = _find_submenu_id(menu->menu, numbuf); 1301 tmphandle = _find_submenu_id(menu->menu, numbuf);
1180 1302
1181 if(tmphandle) 1303 if(tmphandle)
1182 { 1304 {
1305 _dw_ignore_click = 1;
1183 if(GTK_CHECK_MENU_ITEM(tmphandle)->active != check) 1306 if(GTK_CHECK_MENU_ITEM(tmphandle)->active != check)
1184 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check); 1307 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tmphandle), check);
1308 _dw_ignore_click = 0;
1185 } 1309 }
1186 DW_MUTEX_UNLOCK; 1310 DW_MUTEX_UNLOCK;
1187 } 1311 }
1188 1312
1189 /* 1313 /*
1285 * text: The text to be display by the static text widget. 1409 * text: The text to be display by the static text widget.
1286 * id: An ID to be used with WinWindowFromID() or 0L. 1410 * id: An ID to be used with WinWindowFromID() or 0L.
1287 */ 1411 */
1288 HWND dw_status_text_new(char *text, ULONG id) 1412 HWND dw_status_text_new(char *text, ULONG id)
1289 { 1413 {
1290 GtkWidget *tmp; 1414 GtkWidget *tmp, *frame;
1291 int _locked_by_me = FALSE; 1415 int _locked_by_me = FALSE;
1292 1416
1293 DW_MUTEX_LOCK; 1417 DW_MUTEX_LOCK;
1418 frame = gtk_frame_new(NULL);
1419 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
1294 tmp = gtk_label_new(text); 1420 tmp = gtk_label_new(text);
1421 gtk_container_add(GTK_CONTAINER(frame), tmp);
1422 gtk_widget_show(tmp);
1423 gtk_widget_show(frame);
1295 gtk_label_set_justify(GTK_LABEL(tmp), GTK_JUSTIFY_LEFT); 1424 gtk_label_set_justify(GTK_LABEL(tmp), GTK_JUSTIFY_LEFT);
1296 gtk_widget_show(tmp); 1425 gtk_object_set_data(GTK_OBJECT(frame), "id", (gpointer)id);
1297 gtk_object_set_data(GTK_OBJECT(tmp), "id", (gpointer)id); 1426 gtk_object_set_data(GTK_OBJECT(frame), "label", (gpointer)tmp);
1298 DW_MUTEX_UNLOCK; 1427 DW_MUTEX_UNLOCK;
1299 return tmp; 1428 return frame;
1300 } 1429 }
1301 1430
1302 /* 1431 /*
1303 * Create a new Multiline Editbox window (widget) to be packed. 1432 * Create a new Multiline Editbox window (widget) to be packed.
1304 * Parameters: 1433 * Parameters:
1535 * Create a new listbox window (widget) to be packed. 1664 * Create a new listbox window (widget) to be packed.
1536 * Parameters: 1665 * Parameters:
1537 * id: An ID to be used with WinWindowFromID() or 0L. 1666 * id: An ID to be used with WinWindowFromID() or 0L.
1538 * multi: Multiple select TRUE or FALSE. 1667 * multi: Multiple select TRUE or FALSE.
1539 */ 1668 */
1540 HWND dw_listbox_new(unsigned long id, int multi) 1669 HWND dw_listbox_new(unsigned long id, int multi)
1541 { 1670 {
1542 GtkWidget *tmp, *list; 1671 GtkWidget *tmp, *list;
1543 int _locked_by_me = FALSE; 1672 int _locked_by_me = FALSE;
1544 1673
1545 DW_MUTEX_LOCK; 1674 DW_MUTEX_LOCK;
1616 gtk_entry_set_text(GTK_ENTRY(handle), text); 1745 gtk_entry_set_text(GTK_ENTRY(handle), text);
1617 else if(GTK_IS_COMBO(handle)) 1746 else if(GTK_IS_COMBO(handle))
1618 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(handle)->entry), text); 1747 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(handle)->entry), text);
1619 else if(GTK_IS_LABEL(handle)) 1748 else if(GTK_IS_LABEL(handle))
1620 gtk_label_set_text(GTK_LABEL(handle), text); 1749 gtk_label_set_text(GTK_LABEL(handle), text);
1750 else if(GTK_IS_FRAME(handle))
1751 {
1752 GtkWidget *tmp = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "label");
1753 if(tmp && GTK_IS_LABEL(tmp))
1754 gtk_label_set_text(GTK_LABEL(tmp), text);
1755 }
1621 DW_MUTEX_UNLOCK; 1756 DW_MUTEX_UNLOCK;
1622 } 1757 }
1623 1758
1624 /* 1759 /*
1625 * Gets the text used for a given window. 1760 * Gets the text used for a given window.
2269 */ 2404 */
2270 void *dw_container_alloc(HWND handle, int rowcount) 2405 void *dw_container_alloc(HWND handle, int rowcount)
2271 { 2406 {
2272 int z, count = 0; 2407 int z, count = 0;
2273 GtkWidget *clist; 2408 GtkWidget *clist;
2409 GdkColor *fore, *back;
2274 char **blah; 2410 char **blah;
2275 int _locked_by_me = FALSE; 2411 int _locked_by_me = FALSE;
2276 2412
2277 DW_MUTEX_LOCK; 2413 DW_MUTEX_LOCK;
2278 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle)); 2414 clist = (GtkWidget *)gtk_object_get_user_data(GTK_OBJECT(handle));
2291 } 2427 }
2292 2428
2293 blah = malloc(sizeof(char *) * count); 2429 blah = malloc(sizeof(char *) * count);
2294 memset(blah, 0, sizeof(char *) * count); 2430 memset(blah, 0, sizeof(char *) * count);
2295 2431
2432 fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "foregdk");
2433 back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(clist), "backgdk");
2296 gtk_clist_freeze(GTK_CLIST(clist)); 2434 gtk_clist_freeze(GTK_CLIST(clist));
2297 for(z=0;z<rowcount;z++) 2435 for(z=0;z<rowcount;z++)
2298 { 2436 {
2299 gtk_clist_append(GTK_CLIST(clist), blah); 2437 gtk_clist_append(GTK_CLIST(clist), blah);
2300 } 2438 if(fore)
2439 gtk_clist_set_foreground(GTK_CLIST(clist), z, fore);
2440 if(back)
2441 gtk_clist_set_background(GTK_CLIST(clist), z, back);
2442 }
2443 gtk_object_set_data(GTK_OBJECT(clist), "rowcount", (gpointer)rowcount);
2301 free(blah); 2444 free(blah);
2302 DW_MUTEX_UNLOCK; 2445 DW_MUTEX_UNLOCK;
2303 return (void *)handle; 2446 return (void *)handle;
2304 } 2447 }
2305 2448
2458 { 2601 {
2459 list = (GList *)gtk_object_get_data(GTK_OBJECT(clist), "selectlist"); 2602 list = (GList *)gtk_object_get_data(GTK_OBJECT(clist), "selectlist");
2460 g_list_free(list); 2603 g_list_free(list);
2461 gtk_object_set_data(GTK_OBJECT(clist), "selectlist", NULL); 2604 gtk_object_set_data(GTK_OBJECT(clist), "selectlist", NULL);
2462 gtk_clist_clear(GTK_CLIST(clist)); 2605 gtk_clist_clear(GTK_CLIST(clist));
2606 gtk_object_set_data(GTK_OBJECT(clist), "rowcount", (gpointer)0);
2463 } 2607 }
2464 DW_MUTEX_UNLOCK; 2608 DW_MUTEX_UNLOCK;
2465 } 2609 }
2466 2610
2467 /* 2611 /*
3222 void dw_window_set_pos(HWND handle, unsigned long x, unsigned long y) 3366 void dw_window_set_pos(HWND handle, unsigned long x, unsigned long y)
3223 { 3367 {
3224 int _locked_by_me = FALSE; 3368 int _locked_by_me = FALSE;
3225 3369
3226 DW_MUTEX_LOCK; 3370 DW_MUTEX_LOCK;
3227 if(handle->window) 3371 if(handle && handle->window)
3228 gdk_window_move(handle->window, x, y); 3372 gdk_window_move(handle->window, x, y);
3229 DW_MUTEX_UNLOCK; 3373 DW_MUTEX_UNLOCK;
3230 } 3374 }
3231 3375
3232 /* 3376 /*
3241 void dw_window_set_pos_size(HWND handle, unsigned long x, unsigned long y, unsigned long width, unsigned long height) 3385 void dw_window_set_pos_size(HWND handle, unsigned long x, unsigned long y, unsigned long width, unsigned long height)
3242 { 3386 {
3243 int _locked_by_me = FALSE; 3387 int _locked_by_me = FALSE;
3244 3388
3245 DW_MUTEX_LOCK; 3389 DW_MUTEX_LOCK;
3246 if(GTK_IS_WINDOW(handle)) 3390 if(handle && GTK_IS_WINDOW(handle))
3247 { 3391 {
3392 GdkWindow *parent = gdk_window_get_parent(handle->window);
3393 int cx = (int)gtk_object_get_data(GTK_OBJECT(handle), "cx");
3394 int cy = (int)gtk_object_get_data(GTK_OBJECT(handle), "cy");
3395
3248 _size_allocate(GTK_WINDOW(handle)); 3396 _size_allocate(GTK_WINDOW(handle));
3249 gtk_widget_set_uposition(handle, x, y); 3397 #if 0
3250 gtk_window_set_default_size(GTK_WINDOW(handle), width, height); 3398 if(parent)
3251 } 3399 {
3252 else if(handle->window) 3400 gdk_window_resize(parent, width, height);
3401 gdk_window_move(parent, x, y);
3402 }
3403 else
3404 #endif
3405 {
3406 gtk_widget_set_uposition(handle, x, y);
3407 gtk_window_set_default_size(GTK_WINDOW(handle), width - cx, height - cy);
3408 }
3409 }
3410 else if(handle && handle->window)
3253 { 3411 {
3254 gdk_window_resize(handle->window, width, height); 3412 gdk_window_resize(handle->window, width, height);
3255 gdk_window_move(handle->window, x, y); 3413 gdk_window_move(handle->window, x, y);
3256 } 3414 }
3257 DW_MUTEX_UNLOCK; 3415 DW_MUTEX_UNLOCK;
3271 int _locked_by_me = FALSE; 3429 int _locked_by_me = FALSE;
3272 gint gx, gy, gwidth, gheight, gdepth; 3430 gint gx, gy, gwidth, gheight, gdepth;
3273 3431
3274 if(handle && handle->window) 3432 if(handle && handle->window)
3275 { 3433 {
3434 int cx, cy;
3435
3276 DW_MUTEX_LOCK; 3436 DW_MUTEX_LOCK;
3437
3438 cx = (int)gtk_object_get_data(GTK_OBJECT(handle), "cx");
3439 cy = (int)gtk_object_get_data(GTK_OBJECT(handle), "cy");
3440
3277 gdk_window_get_geometry(handle->window, &gx, &gy, &gwidth, &gheight, &gdepth); 3441 gdk_window_get_geometry(handle->window, &gx, &gy, &gwidth, &gheight, &gdepth);
3278 gdk_window_get_root_origin(handle->window, &gx, &gy); 3442 gdk_window_get_root_origin(handle->window, &gx, &gy);
3279 if(x) 3443 if(x)
3280 *x = gx; 3444 *x = gx;
3281 if(y) 3445 if(y)
3282 *y = gy; 3446 *y = gy;
3283 if(width) 3447 if(width)
3284 *width = gwidth; 3448 *width = gwidth - cx;
3285 if(height) 3449 if(height)
3286 *height = gheight; 3450 *height = gheight - cy;
3287 DW_MUTEX_UNLOCK; 3451 DW_MUTEX_UNLOCK;
3288 } 3452 }
3289 } 3453 }
3290 3454
3291 /* 3455 /*
3461 if(GTK_IS_LIST(handle2)) 3625 if(GTK_IS_LIST(handle2))
3462 { 3626 {
3463 GtkWidget *list_item; 3627 GtkWidget *list_item;
3464 GList *tmp; 3628 GList *tmp;
3465 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "font"); 3629 char *font = (char *)gtk_object_get_data(GTK_OBJECT(handle), "font");
3466 unsigned long fore = (unsigned long)gtk_object_get_data(GTK_OBJECT(handle), "fore"); 3630 GdkColor *fore = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "foregdk");
3467 unsigned long back = (unsigned long)gtk_object_get_data(GTK_OBJECT(handle), "back"); 3631 GdkColor *back = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle2), "backgdk");
3468 3632
3469 list_item=gtk_list_item_new_with_label(text); 3633 list_item=gtk_list_item_new_with_label(text);
3470 3634
3471 if(font) 3635 if(font)
3472 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font); 3636 _set_font(GTK_LIST_ITEM(list_item)->item.bin.child, font);
3473 if(fore && back) 3637 if(fore && back)
3474 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child, fore, back); 3638 _set_color(GTK_LIST_ITEM(list_item)->item.bin.child,
3639 DW_RGB(fore->red, fore->green, fore->blue),
3640 DW_RGB(back->red, back->green, back->blue));
3475 3641
3476 tmp = g_list_append(NULL, list_item); 3642 tmp = g_list_append(NULL, list_item);
3477 gtk_widget_show(list_item); 3643 gtk_widget_show(list_item);
3478 gtk_list_append_items(GTK_LIST(handle2),tmp); 3644 gtk_list_append_items(GTK_LIST(handle2),tmp);
3479 } 3645 }
4194 } 4360 }
4195 else if(GTK_IS_LIST(thiswindow) && strcmp(signame, "item-select") == 0) 4361 else if(GTK_IS_LIST(thiswindow) && strcmp(signame, "item-select") == 0)
4196 { 4362 {
4197 thisname = "select_child"; 4363 thisname = "select_child";
4198 } 4364 }
4365 else if(GTK_IS_WINDOW(thiswindow) && strcmp(signame, "set-focus") == 0)
4366 {
4367 thisname = "focus-in-event";
4368 }
4199 4369
4200 if(!thisfunc || !thiswindow) 4370 if(!thisfunc || !thiswindow)
4201 { 4371 {
4202 free(work); 4372 free(work);
4203 DW_MUTEX_UNLOCK; 4373 DW_MUTEX_UNLOCK;