Mercurial > dwindows

comparison gtk3/dw.c @ 1087:173e49c2270f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge all 3 box packing functions into one internal function on GTK3.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Tue, 28 Jun 2011 20:04:27 +0000
parents f9232a52367a
children 0fc7387abfd1
comparison
equal deleted inserted replaced
1086:4254c9b6d50d 1087:173e49c2270f
8041 gtk_container_child_set(cont, widget, "top-attach", (oldpos + 1), "bottom-attach", (oldpos+2), NULL); 8041 gtk_container_child_set(cont, widget, "top-attach", (oldpos + 1), "bottom-attach", (oldpos+2), NULL);
8042 } 8042 }
8043 } 8043 }
8044 } 8044 }
8045 8045
8046 /* Internal box packing function called by the other 3 functions */
8047 void _dw_box_pack(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad, char *funcname)
8048 {
8049 int warn = FALSE, _locked_by_me = FALSE;
8050 GtkWidget *tmp, *tmpitem, *image = NULL;
8051
8052 if(!box)
8053 return;
8054
8055 /*
8056 * If you try and pack an item into itself VERY bad things can happen; like at least an
8057 * infinite loop on GTK! Lets be safe!
8058 */
8059 if(box == item)
8060 {
8061 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!");
8062 return;
8063 }
8064
8065 DW_MUTEX_LOCK;
8066
8067 if((tmp = g_object_get_data(G_OBJECT(box), "_dw_boxhandle")))
8068 box = tmp;
8069
8070 if(!item)
8071 {
8072 item = gtk_label_new("");
8073 gtk_widget_show_all(item);
8074 }
8075 else if((image = g_object_get_data(G_OBJECT(item), "_dw_bitmap")))
8076 {
8077 GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
8078
8079 if(pixbuf)
8080 {
8081 int pwidth = gdk_pixbuf_get_width(pixbuf);
8082 int pheight = gdk_pixbuf_get_height(pixbuf);
8083
8084 if(pwidth > width || pheight > height)
8085 {
8086 pixbuf = gdk_pixbuf_scale_simple(pixbuf, pwidth > width ? width : pwidth, pheight > height ? height : pheight, GDK_INTERP_BILINEAR);
8087 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
8088 }
8089 }
8090 }
8091
8092 tmpitem = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_boxhandle");
8093
8094 if(GTK_IS_TABLE(box))
8095 {
8096 int boxcount = (int)g_object_get_data(G_OBJECT(box), "_dw_boxcount");
8097 int boxtype = (int)g_object_get_data(G_OBJECT(box), "_dw_boxtype");
8098 int x, y;
8099
8100 /* If the item being packed is a box, then we use it's padding
8101 * instead of the padding specified on the pack line, this is
8102 * due to a bug in the OS/2 and Win32 renderer and a limitation
8103 * of the GtkTable class.
8104 */
8105 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8106 {
8107 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8108
8109 /* NOTE: I left in the ability to pack boxes with a size,
8110 * this eliminates that by forcing the size to 0.
8111 */
8112 height = width = 0;
8113
8114 if(eventbox)
8115 {
8116 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8117 gtk_container_add(GTK_CONTAINER(eventbox), item);
8118 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8119 item = eventbox;
8120 }
8121 }
8122 else
8123 {
8124 /* Only show warning if item is not a box */
8125 warn = TRUE;
8126 }
8127
8128 /* Do some sanity bounds checking */
8129 if(index < 0)
8130 index = 0;
8131 if(index > boxcount)
8132 index = boxcount;
8133
8134 if(boxtype == DW_VERT)
8135 {
8136 x = 0;
8137 y = index;
8138 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
8139 }
8140 else
8141 {
8142 x = index;
8143 y = 0;
8144 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
8145 }
8146
8147 g_object_set_data(G_OBJECT(item), "_dw_table", box);
8148 if(index < boxcount)
8149 gtk_container_forall(GTK_CONTAINER(box),_rearrange_table, GINT_TO_POINTER(boxtype == DW_VERT ? index : -(index+1)));
8150 gtk_table_attach(GTK_TABLE(box), item, x, x + 1, y, y + 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
8151 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
8152 if(GTK_IS_SCROLLED_WINDOW(item))
8153 {
8154 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
8155 gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(item), height);
8156 }
8157 else
8158 gtk_widget_set_size_request(item, width, height);
8159 if(GTK_IS_RADIO_BUTTON(item))
8160 {
8161 GSList *group;
8162 GtkWidget *groupstart = (GtkWidget *)g_object_get_data(G_OBJECT(box), "_dw_group");
8163
8164 if(groupstart)
8165 {
8166 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(groupstart));
8167 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
8168 }
8169 else
8170 g_object_set_data(G_OBJECT(box), "_dw_group", (gpointer)item);
8171 }
8172 }
8173 else
8174 {
8175 GtkWidget *vbox = g_object_get_data(G_OBJECT(box), "_dw_vbox");
8176
8177 if(!vbox)
8178 {
8179 vbox = gtk_vbox_new(FALSE, 0);
8180 g_object_set_data(G_OBJECT(box), "_dw_vbox", vbox);
8181 gtk_container_add(GTK_CONTAINER(box), vbox);
8182 gtk_widget_show(vbox);
8183 }
8184
8185 gtk_container_set_border_width(GTK_CONTAINER(box), pad);
8186
8187 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8188 {
8189 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8190
8191 /* NOTE: I left in the ability to pack boxes with a size,
8192 * this eliminates that by forcing the size to 0.
8193 */
8194 height = width = 0;
8195
8196 if(eventbox)
8197 {
8198 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8199 gtk_container_add(GTK_CONTAINER(eventbox), item);
8200 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8201 item = eventbox;
8202 }
8203 }
8204 else
8205 {
8206 /* Only show warning if item is not a box */
8207 warn = TRUE;
8208 }
8209
8210 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
8211
8212 gtk_widget_set_size_request(item, width, height);
8213 g_object_set_data(G_OBJECT(box), "_dw_user", vbox);
8214 }
8215 DW_MUTEX_UNLOCK;
8216
8217 if(warn)
8218 {
8219 if ( width == 0 && hsize == FALSE )
8220 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
8221 if ( height == 0 && vsize == FALSE )
8222 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
8223 }
8224 }
8225
8046 /* 8226 /*
8047 * Pack windows (widgets) into a box at an arbitrary location. 8227 * Pack windows (widgets) into a box at an arbitrary location.
8048 * Parameters: 8228 * Parameters:
8049 * box: Window handle of the box to be packed into. 8229 * box: Window handle of the box to be packed into.
8050 * item: Window handle of the item to be back. 8230 * item: Window handle of the item to be back.
8053 * height: Height in pixels of the item or -1 to be self determined. 8233 * height: Height in pixels of the item or -1 to be self determined.
8054 * hsize: TRUE if the window (widget) should expand horizontally to fill space given. 8234 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
8055 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 8235 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
8056 * pad: Number of pixels of padding around the item. 8236 * pad: Number of pixels of padding around the item.
8057 */ 8237 */
8058 void dw_box_pack_at_index(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad) 8238 void API dw_box_pack_at_index(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad)
8059 { 8239 {
8060 int warn = FALSE, _locked_by_me = FALSE; 8240 _dw_box_pack(box, item, index, width, height, hsize, vsize, pad, "dw_box_pack_at_index()");
8061 GtkWidget *tmp, *tmpitem, *image = NULL; 8241 }
8062 char *funcname = "dw_box_pack_at_index()"; 8242
8063 8243 /*
8064 if(!box) 8244 * Pack windows (widgets) into a box from the start (or top).
8065 return;
8066
8067 /*
8068 * If you try and pack an item into itself VERY bad things can happen; like at least an
8069 * infinite loop on GTK! Lets be safe!
8070 */
8071 if(box == item)
8072 {
8073 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!");
8074 return;
8075 }
8076
8077 DW_MUTEX_LOCK;
8078
8079 if((tmp = g_object_get_data(G_OBJECT(box), "_dw_boxhandle")))
8080 box = tmp;
8081
8082 if(!item)
8083 {
8084 item = gtk_label_new("");
8085 gtk_widget_show_all(item);
8086 }
8087 else if((image = g_object_get_data(G_OBJECT(item), "_dw_bitmap")))
8088 {
8089 GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
8090
8091 if(pixbuf)
8092 {
8093 int pwidth = gdk_pixbuf_get_width(pixbuf);
8094 int pheight = gdk_pixbuf_get_height(pixbuf);
8095
8096 if(pwidth > width || pheight > height)
8097 {
8098 pixbuf = gdk_pixbuf_scale_simple(pixbuf, pwidth > width ? width : pwidth, pheight > height ? height : pheight, GDK_INTERP_BILINEAR);
8099 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
8100 }
8101 }
8102 }
8103
8104 tmpitem = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_boxhandle");
8105
8106 if(GTK_IS_TABLE(box))
8107 {
8108 int boxcount = (int)g_object_get_data(G_OBJECT(box), "_dw_boxcount");
8109 int boxtype = (int)g_object_get_data(G_OBJECT(box), "_dw_boxtype");
8110 int x, y;
8111
8112 /* If the item being packed is a box, then we use it's padding
8113 * instead of the padding specified on the pack line, this is
8114 * due to a bug in the OS/2 and Win32 renderer and a limitation
8115 * of the GtkTable class.
8116 */
8117 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8118 {
8119 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8120
8121 /* NOTE: I left in the ability to pack boxes with a size,
8122 * this eliminates that by forcing the size to 0.
8123 */
8124 height = width = 0;
8125
8126 if(eventbox)
8127 {
8128 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8129 gtk_container_add(GTK_CONTAINER(eventbox), item);
8130 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8131 item = eventbox;
8132 }
8133 }
8134 else
8135 {
8136 /* Only show warning if item is not a box */
8137 warn = TRUE;
8138 }
8139
8140 /* Do some sanity bounds checking */
8141 if(index < 0)
8142 index = 0;
8143 if(index > boxcount)
8144 index = boxcount;
8145
8146 if(boxtype == DW_VERT)
8147 {
8148 x = 0;
8149 y = index;
8150 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
8151 }
8152 else
8153 {
8154 x = index;
8155 y = 0;
8156 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
8157 }
8158
8159 g_object_set_data(G_OBJECT(item), "_dw_table", box);
8160 gtk_container_forall(GTK_CONTAINER(box),_rearrange_table, GINT_TO_POINTER(boxtype == DW_VERT ? index : -(index+1)));
8161 gtk_table_attach(GTK_TABLE(box), item, x, x + 1, y, y + 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
8162 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
8163 if(GTK_IS_SCROLLED_WINDOW(item))
8164 {
8165 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
8166 gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(item), height);
8167 }
8168 else
8169 gtk_widget_set_size_request(item, width, height);
8170 if(GTK_IS_RADIO_BUTTON(item))
8171 {
8172 GSList *group;
8173 GtkWidget *groupstart = (GtkWidget *)g_object_get_data(G_OBJECT(box), "_dw_group");
8174
8175 if(groupstart)
8176 {
8177 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(groupstart));
8178 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
8179 }
8180 else
8181 g_object_set_data(G_OBJECT(box), "_dw_group", (gpointer)item);
8182 }
8183 }
8184 else
8185 {
8186 GtkWidget *vbox = g_object_get_data(G_OBJECT(box), "_dw_vbox");
8187
8188 if(!vbox)
8189 {
8190 vbox = gtk_vbox_new(FALSE, 0);
8191 g_object_set_data(G_OBJECT(box), "_dw_vbox", vbox);
8192 gtk_container_add(GTK_CONTAINER(box), vbox);
8193 gtk_widget_show(vbox);
8194 }
8195
8196 gtk_container_set_border_width(GTK_CONTAINER(box), pad);
8197
8198 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8199 {
8200 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8201
8202 /* NOTE: I left in the ability to pack boxes with a size,
8203 * this eliminates that by forcing the size to 0.
8204 */
8205 height = width = 0;
8206
8207 if(eventbox)
8208 {
8209 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8210 gtk_container_add(GTK_CONTAINER(eventbox), item);
8211 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8212 item = eventbox;
8213 }
8214 }
8215 else
8216 {
8217 /* Only show warning if item is not a box */
8218 warn = TRUE;
8219 }
8220
8221 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
8222
8223 gtk_widget_set_size_request(item, width, height);
8224 g_object_set_data(G_OBJECT(box), "_dw_user", vbox);
8225 }
8226 DW_MUTEX_UNLOCK;
8227
8228 if(warn)
8229 {
8230 if ( width == 0 && hsize == FALSE )
8231 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
8232 if ( height == 0 && vsize == FALSE )
8233 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
8234 }
8235 }
8236
8237 /*
8238 * Pack windows (widgets) into a box from the end (or bottom).
8239 * Parameters: 8245 * Parameters:
8240 * box: Window handle of the box to be packed into. 8246 * box: Window handle of the box to be packed into.
8241 * item: Window handle of the item to be back. 8247 * item: Window handle of the item to be back.
8242 * width: Width in pixels of the item or -1 to be self determined. 8248 * width: Width in pixels of the item or -1 to be self determined.
8243 * height: Height in pixels of the item or -1 to be self determined. 8249 * height: Height in pixels of the item or -1 to be self determined.
8244 * hsize: TRUE if the window (widget) should expand horizontally to fill space given. 8250 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
8245 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 8251 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
8246 * pad: Number of pixels of padding around the item. 8252 * pad: Number of pixels of padding around the item.
8247 */ 8253 */
8248 void dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad) 8254 void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
8249 { 8255 {
8250 int warn = FALSE, _locked_by_me = FALSE; 8256 /* 65536 is the table limit on GTK...
8251 GtkWidget *tmp, *tmpitem, *image = NULL; 8257 * seems like a high enough value we will never hit it here either.
8252 char *funcname = "dw_box_pack_end()"; 8258 */
8253 8259 _dw_box_pack(box, item, 65536, width, height, hsize, vsize, pad, "dw_box_pack_start()");
8254 if(!box) 8260 }
8255 return; 8261
8256 8262 /*
8257 /* 8263 * Pack windows (widgets) into a box from the end (or bottom).
8258 * If you try and pack an item into itself VERY bad things can happen; like at least an 8264 * Parameters:
8259 * infinite loop on GTK! Lets be safe! 8265 * box: Window handle of the box to be packed into.
8260 */ 8266 * item: Window handle of the item to be back.
8261 if(box == item) 8267 * width: Width in pixels of the item or -1 to be self determined.
8262 { 8268 * height: Height in pixels of the item or -1 to be self determined.
8263 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!"); 8269 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
8264 return; 8270 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
8265 } 8271 * pad: Number of pixels of padding around the item.
8266 8272 */
8267 DW_MUTEX_LOCK; 8273 void API dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
8268 8274 {
8269 if((tmp = g_object_get_data(G_OBJECT(box), "_dw_boxhandle"))) 8275 _dw_box_pack(box, item, 0, width, height, hsize, vsize, pad, "dw_box_pack_end()");
8270 box = tmp;
8271
8272 if(!item)
8273 {
8274 item = gtk_label_new("");
8275 gtk_widget_show_all(item);
8276 }
8277 else if((image = g_object_get_data(G_OBJECT(item), "_dw_bitmap")))
8278 {
8279 GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
8280
8281 if(pixbuf)
8282 {
8283 int pwidth = gdk_pixbuf_get_width(pixbuf);
8284 int pheight = gdk_pixbuf_get_height(pixbuf);
8285
8286 if(pwidth > width || pheight > height)
8287 {
8288 pixbuf = gdk_pixbuf_scale_simple(pixbuf, pwidth > width ? width : pwidth, pheight > height ? height : pheight, GDK_INTERP_BILINEAR);
8289 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
8290 }
8291 }
8292 }
8293
8294 tmpitem = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_boxhandle");
8295
8296 if(GTK_IS_TABLE(box))
8297 {
8298 int boxcount = (int)g_object_get_data(G_OBJECT(box), "_dw_boxcount");
8299 int boxtype = (int)g_object_get_data(G_OBJECT(box), "_dw_boxtype");
8300
8301 /* If the item being packed is a box, then we use it's padding
8302 * instead of the padding specified on the pack line, this is
8303 * due to a bug in the OS/2 and Win32 renderer and a limitation
8304 * of the GtkTable class.
8305 */
8306 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8307 {
8308 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8309
8310 /* NOTE: I left in the ability to pack boxes with a size,
8311 * this eliminates that by forcing the size to 0.
8312 */
8313 height = width = 0;
8314
8315 if(eventbox)
8316 {
8317 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8318 gtk_container_add(GTK_CONTAINER(eventbox), item);
8319 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8320 item = eventbox;
8321 }
8322 }
8323 else
8324 {
8325 /* Only show warning if item is not a box */
8326 warn = TRUE;
8327 }
8328
8329 if(boxtype == DW_VERT)
8330 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
8331 else
8332 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
8333
8334 g_object_set_data(G_OBJECT(item), "_dw_table", box);
8335 gtk_table_attach(GTK_TABLE(box), item, 0, 1, 0, 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
8336 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
8337 if(GTK_IS_SCROLLED_WINDOW(item))
8338 {
8339 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
8340 gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(item), height);
8341 }
8342 else
8343 gtk_widget_set_size_request(item, width, height);
8344 if(GTK_IS_RADIO_BUTTON(item))
8345 {
8346 GSList *group;
8347 GtkWidget *groupstart = (GtkWidget *)g_object_get_data(G_OBJECT(box), "_dw_group");
8348
8349 if(groupstart)
8350 {
8351 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(groupstart));
8352 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
8353 }
8354 else
8355 g_object_set_data(G_OBJECT(box), "_dw_group", (gpointer)item);
8356 }
8357 }
8358 else
8359 {
8360 GtkWidget *vbox = g_object_get_data(G_OBJECT(box), "_dw_vbox");
8361
8362 if(!vbox)
8363 {
8364 vbox = gtk_vbox_new(FALSE, 0);
8365 g_object_set_data(G_OBJECT(box), "_dw_vbox", vbox);
8366 gtk_container_add(GTK_CONTAINER(box), vbox);
8367 gtk_widget_show(vbox);
8368 }
8369
8370 gtk_container_set_border_width(GTK_CONTAINER(box), pad);
8371
8372 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
8373 {
8374 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
8375
8376 /* NOTE: I left in the ability to pack boxes with a size,
8377 * this eliminates that by forcing the size to 0.
8378 */
8379 height = width = 0;
8380
8381 if(eventbox)
8382 {
8383 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
8384 gtk_container_add(GTK_CONTAINER(eventbox), item);
8385 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
8386 item = eventbox;
8387 }
8388 }
8389 else
8390 {
8391 /* Only show warning if item is not a box */
8392 warn = TRUE;
8393 }
8394
8395 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
8396
8397 gtk_widget_set_size_request(item, width, height);
8398 g_object_set_data(G_OBJECT(box), "_dw_user", vbox);
8399 }
8400 DW_MUTEX_UNLOCK;
8401
8402 if(warn)
8403 {
8404 if ( width == 0 && hsize == FALSE )
8405 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
8406 if ( height == 0 && vsize == FALSE )
8407 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
8408 }
8409 } 8276 }
8410 8277
8411 /* 8278 /*
8412 * Sets the size of a given window (widget). 8279 * Sets the size of a given window (widget).
8413 * Parameters: 8280 * Parameters:
9620 DW_MUTEX_UNLOCK; 9487 DW_MUTEX_UNLOCK;
9621 return; 9488 return;
9622 } 9489 }
9623 9490
9624 /* 9491 /*
9625 * Pack windows (widgets) into a box from the start (or top).
9626 * Parameters:
9627 * box: Window handle of the box to be packed into.
9628 * item: Window handle of the item to be back.
9629 * width: Width in pixels of the item or -1 to be self determined.
9630 * height: Height in pixels of the item or -1 to be self determined.
9631 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
9632 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
9633 * pad: Number of pixels of padding around the item.
9634 */
9635 void dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
9636 {
9637 int warn = FALSE, _locked_by_me = FALSE;
9638 GtkWidget *tmp, *tmpitem, *image = NULL;
9639 char *funcname = "dw_box_pack_start()";
9640
9641 if ( !box )
9642 return;
9643
9644 /*
9645 * If you try and pack an item into itself VERY bad things can happen; like at least an
9646 * infinite loop on GTK! Lets be safe!
9647 */
9648 if ( box == item )
9649 {
9650 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!" );
9651 return;
9652 }
9653
9654 DW_MUTEX_LOCK;
9655
9656 if ((tmp = g_object_get_data(G_OBJECT(box), "_dw_boxhandle")))
9657 box = tmp;
9658
9659 if (!item)
9660 {
9661 item = gtk_label_new("");
9662 gtk_widget_show_all(item);
9663 }
9664 else if((image = g_object_get_data(G_OBJECT(item), "_dw_bitmap")))
9665 {
9666 GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
9667
9668 if(pixbuf)
9669 {
9670 int pwidth = gdk_pixbuf_get_width(pixbuf);
9671 int pheight = gdk_pixbuf_get_height(pixbuf);
9672
9673 if(pwidth > width || pheight > height)
9674 {
9675 pixbuf = gdk_pixbuf_scale_simple(pixbuf, pwidth > width ? width : pwidth, pheight > height ? height : pheight, GDK_INTERP_BILINEAR);
9676 gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
9677 }
9678 }
9679 }
9680
9681 tmpitem = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_boxhandle");
9682
9683 if (GTK_IS_TABLE(box))
9684 {
9685 int boxcount = (int)g_object_get_data(G_OBJECT(box), "_dw_boxcount");
9686 int boxtype = (int)g_object_get_data(G_OBJECT(box), "_dw_boxtype");
9687 int x, y;
9688
9689 /* If the item being packed is a box, then we use it's padding
9690 * instead of the padding specified on the pack line, this is
9691 * due to a bug in the OS/2 and Win32 renderer and a limitation
9692 * of the GtkTable class.
9693 */
9694 if (GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
9695 {
9696 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
9697
9698 /* NOTE: I left in the ability to pack boxes with a size,
9699 * this eliminates that by forcing the size to 0.
9700 */
9701 height = width = 0;
9702
9703 if (eventbox)
9704 {
9705 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
9706 gtk_container_add(GTK_CONTAINER(eventbox), item);
9707 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
9708 item = eventbox;
9709 }
9710 }
9711 else
9712 {
9713 /* Only show warning if item is not a box */
9714 warn = TRUE;
9715 }
9716
9717 if (boxtype == DW_VERT)
9718 {
9719 x = 0;
9720 y = boxcount;
9721 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
9722 }
9723 else
9724 {
9725 x = boxcount;
9726 y = 0;
9727 gtk_table_resize(GTK_TABLE(box), 1, boxcount + 1);
9728 }
9729
9730 g_object_set_data(G_OBJECT(item), "_dw_table", box);
9731 gtk_table_attach(GTK_TABLE(box), item, x, x + 1, y, y + 1, hsize ? DW_EXPAND : 0, vsize ? DW_EXPAND : 0, pad, pad);
9732 g_object_set_data(G_OBJECT(box), "_dw_boxcount", GINT_TO_POINTER(boxcount + 1));
9733 if(GTK_IS_SCROLLED_WINDOW(item))
9734 {
9735 gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(item), width);
9736 gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(item), height);
9737 }
9738 else
9739 gtk_widget_set_size_request(item, width, height);
9740 if (GTK_IS_RADIO_BUTTON(item))
9741 {
9742 GSList *group;
9743 GtkWidget *groupstart = (GtkWidget *)g_object_get_data(G_OBJECT(box), "_dw_group");
9744
9745 if (groupstart)
9746 {
9747 group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(groupstart));
9748 gtk_radio_button_set_group(GTK_RADIO_BUTTON(item), group);
9749 }
9750 else
9751 {
9752 g_object_set_data(G_OBJECT(box), "_dw_group", (gpointer)item);
9753 }
9754 }
9755 }
9756 else
9757 {
9758 GtkWidget *vbox = g_object_get_data(G_OBJECT(box), "_dw_vbox");
9759
9760 if(!vbox)
9761 {
9762 vbox = gtk_vbox_new(FALSE, 0);
9763 g_object_set_data(G_OBJECT(box), "_dw_vbox", vbox);
9764 gtk_container_add(GTK_CONTAINER(box), vbox);
9765 gtk_widget_show(vbox);
9766 }
9767
9768 gtk_container_set_border_width(GTK_CONTAINER(box), pad);
9769
9770 if (GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
9771 {
9772 GtkWidget *eventbox = (GtkWidget *)g_object_get_data(G_OBJECT(item), "_dw_eventbox");
9773
9774 /* NOTE: I left in the ability to pack boxes with a size,
9775 * this eliminates that by forcing the size to 0.
9776 */
9777 height = width = 0;
9778
9779 if (eventbox)
9780 {
9781 int boxpad = (int)g_object_get_data(G_OBJECT(item), "_dw_boxpad");
9782 gtk_container_add(GTK_CONTAINER(eventbox), item);
9783 gtk_container_set_border_width(GTK_CONTAINER(eventbox), boxpad);
9784 item = eventbox;
9785 }
9786 }
9787 else
9788 {
9789 /* Only show warning if item is not a box */
9790 warn = TRUE;
9791 }
9792
9793 gtk_box_pack_end(GTK_BOX(vbox), item, TRUE, TRUE, 0);
9794
9795 gtk_widget_set_size_request(item, width, height);
9796 g_object_set_data(G_OBJECT(box), "_dw_user", vbox);
9797 }
9798 DW_MUTEX_UNLOCK;
9799
9800 if (warn)
9801 {
9802 if ( width == 0 && hsize == FALSE )
9803 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
9804 if ( height == 0 && vsize == FALSE )
9805 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
9806 }
9807 }
9808
9809 /*
9810 * Sets the default focus item for a window/dialog. 9492 * Sets the default focus item for a window/dialog.
9811 * Parameters: 9493 * Parameters:
9812 * window: Toplevel window or dialog. 9494 * window: Toplevel window or dialog.
9813 * defaultitem: Handle to the dialog item to be default. 9495 * defaultitem: Handle to the dialog item to be default.
9814 */ 9496 */