Mercurial > dwindows

comparison mac/dw.m @ 1086:4254c9b6d50d

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 Mac. Also added a couple of parameter checks and usage message boxes that I had previous left out of the Mac implementation.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Tue, 28 Jun 2011 18:41:23 +0000
parents 5d3acda4acd4
children 25707e9f5ad1
comparison
equal deleted inserted replaced
1085:5a951cfd67ad 1086:4254c9b6d50d
3152 range = [view bounds].size.width; 3152 range = [view bounds].size.width;
3153 } 3153 }
3154 return range; 3154 return range;
3155 } 3155 }
3156 3156
3157 /* Internal box packing function called by the other 3 functions */
3158 void _dw_box_pack(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad, char *funcname)
3159 {
3160 int _locked_by_me = FALSE;
3161 DW_MUTEX_LOCK;
3162 id object = box;
3163 DWBox *view = box;
3164 DWBox *this = item;
3165 Box *thisbox;
3166 int z, x = 0;
3167 Item *tmpitem, *thisitem;
3168
3169 /*
3170 * If you try and pack an item into itself VERY bad things can happen; like at least an
3171 * infinite loop on GTK! Lets be safe!
3172 */
3173 if(box == item)
3174 {
3175 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Danger! Danger! Will Robinson; box and item are the same!");
3176 return;
3177 }
3178
3179 /* Query the objects */
3180 if([ object isKindOfClass:[ NSWindow class ] ])
3181 {
3182 NSWindow *window = box;
3183 view = [window contentView];
3184 }
3185 else if([ object isMemberOfClass:[ DWScrollBox class ] ])
3186 {
3187 DWScrollBox *scrollbox = box;
3188 view = [scrollbox box];
3189 }
3190
3191 thisbox = [view box];
3192 thisitem = thisbox->items;
3193 object = item;
3194
3195 /* Query the objects */
3196 if([ object isKindOfClass:[ DWContainer class ] ])
3197 {
3198 DWContainer *cont = item;
3199 this = item = [cont scrollview];
3200 }
3201 else if([ object isKindOfClass:[ DWTree class ] ])
3202 {
3203 DWTree *tree = item;
3204 this = item = [tree scrollview];
3205 }
3206
3207 /* Do some sanity bounds checking */
3208 if(index < 0)
3209 index = 0;
3210 if(index > thisbox->count)
3211 index = thisbox->count;
3212
3213 /* Duplicate the existing data */
3214 tmpitem = malloc(sizeof(Item)*(thisbox->count+1));
3215
3216 for(z=0;z<thisbox->count;z++)
3217 {
3218 if(z == index)
3219 x++;
3220 tmpitem[x] = thisitem[z];
3221 x++;
3222 }
3223
3224 /* Sanity checks */
3225 if(vsize && !height)
3226 height = 1;
3227 if(hsize && !width)
3228 width = 1;
3229
3230 /* Fill in the item data appropriately */
3231 if([object isKindOfClass:[DWBox class]] || [object isMemberOfClass:[DWGroupBox class]])
3232 tmpitem[index].type = TYPEBOX;
3233 else
3234 {
3235 if ( width == 0 && hsize == FALSE )
3236 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Width and expand Horizonal both unset for box: %x item: %x",box,item);
3237 if ( height == 0 && vsize == FALSE )
3238 dw_messagebox(funcname, DW_MB_OK|DW_MB_ERROR, "Height and expand Vertical both unset for box: %x item: %x",box,item);
3239
3240 tmpitem[index].type = TYPEITEM;
3241 }
3242
3243 tmpitem[index].hwnd = item;
3244 tmpitem[index].origwidth = tmpitem[index].width = width;
3245 tmpitem[index].origheight = tmpitem[index].height = height;
3246 tmpitem[index].pad = pad;
3247 if(hsize)
3248 tmpitem[index].hsize = SIZEEXPAND;
3249 else
3250 tmpitem[index].hsize = SIZESTATIC;
3251
3252 if(vsize)
3253 tmpitem[index].vsize = SIZEEXPAND;
3254 else
3255 tmpitem[index].vsize = SIZESTATIC;
3256
3257 thisbox->items = tmpitem;
3258
3259 /* Update the item count */
3260 thisbox->count++;
3261
3262 /* Add the item to the box */
3263 [view addSubview:this];
3264 /* If we are packing a button... */
3265 if([this isMemberOfClass:[DWButton class]])
3266 {
3267 DWButton *button = (DWButton *)this;
3268
3269 /* Save the parent box so radio
3270 * buttons can use it later.
3271 */
3272 [button setParent:view];
3273 }
3274
3275 /* Free the old data */
3276 if(thisbox->count)
3277 free(thisitem);
3278 DW_MUTEX_UNLOCK;
3279 }
3280
3157 /* 3281 /*
3158 * Pack windows (widgets) into a box at an arbitrary location. 3282 * Pack windows (widgets) into a box at an arbitrary location.
3159 * Parameters: 3283 * Parameters:
3160 * box: Window handle of the box to be packed into. 3284 * box: Window handle of the box to be packed into.
3161 * item: Window handle of the item to be back. 3285 * item: Window handle of the item to be back.
3166 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 3290 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
3167 * pad: Number of pixels of padding around the item. 3291 * pad: Number of pixels of padding around the item.
3168 */ 3292 */
3169 void API dw_box_pack_at_index(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad) 3293 void API dw_box_pack_at_index(HWND box, HWND item, int index, int width, int height, int hsize, int vsize, int pad)
3170 { 3294 {
3171 int _locked_by_me = FALSE; 3295 _dw_box_pack(box, item, index, width, height, hsize, vsize, pad, "dw_box_pack_at_index()");
3172 DW_MUTEX_LOCK; 3296 }
3173 id object = box; 3297
3174 DWBox *view = box; 3298 /*
3175 DWBox *this = item; 3299 * Pack windows (widgets) into a box from the start (or top).
3176 Box *thisbox;
3177 int z, x = 0;
3178 Item *tmpitem, *thisitem;
3179
3180 /* Query the objects */
3181 if([ object isKindOfClass:[ NSWindow class ] ])
3182 {
3183 NSWindow *window = box;
3184 view = [window contentView];
3185 }
3186 else if([ object isMemberOfClass:[ DWScrollBox class ] ])
3187 {
3188 DWScrollBox *scrollbox = box;
3189 view = [scrollbox box];
3190 }
3191
3192 thisbox = [view box];
3193 thisitem = thisbox->items;
3194 object = item;
3195
3196 /* Query the objects */
3197 if([ object isKindOfClass:[ DWContainer class ] ])
3198 {
3199 DWContainer *cont = item;
3200 this = item = [cont scrollview];
3201 }
3202 else if([ object isKindOfClass:[ DWTree class ] ])
3203 {
3204 DWTree *tree = item;
3205 this = item = [tree scrollview];
3206 }
3207
3208 /* Do some sanity bounds checking */
3209 if(index < 0)
3210 index = 0;
3211 if(index > thisbox->count)
3212 index = thisbox->count;
3213
3214 /* Duplicate the existing data */
3215 tmpitem = malloc(sizeof(Item)*(thisbox->count+1));
3216
3217 for(z=0;z<thisbox->count;z++)
3218 {
3219 if(z == index)
3220 x++;
3221 tmpitem[x] = thisitem[z];
3222 x++;
3223 }
3224
3225 /* Sanity checks */
3226 if(vsize && !height)
3227 height = 1;
3228 if(hsize && !width)
3229 width = 1;
3230
3231 /* Fill in the item data appropriately */
3232 if([object isKindOfClass:[DWBox class]] || [object isMemberOfClass:[DWGroupBox class]])
3233 tmpitem[index].type = TYPEBOX;
3234 else
3235 tmpitem[index].type = TYPEITEM;
3236
3237 tmpitem[index].hwnd = item;
3238 tmpitem[index].origwidth = tmpitem[index].width = width;
3239 tmpitem[index].origheight = tmpitem[index].height = height;
3240 tmpitem[index].pad = pad;
3241 if(hsize)
3242 tmpitem[index].hsize = SIZEEXPAND;
3243 else
3244 tmpitem[index].hsize = SIZESTATIC;
3245
3246 if(vsize)
3247 tmpitem[index].vsize = SIZEEXPAND;
3248 else
3249 tmpitem[index].vsize = SIZESTATIC;
3250
3251 thisbox->items = tmpitem;
3252
3253 /* Update the item count */
3254 thisbox->count++;
3255
3256 /* Add the item to the box */
3257 [view addSubview:this];
3258 /* If we are packing a button... */
3259 if([this isMemberOfClass:[DWButton class]])
3260 {
3261 DWButton *button = (DWButton *)this;
3262
3263 /* Save the parent box so radio
3264 * buttons can use it later.
3265 */
3266 [button setParent:view];
3267 }
3268
3269 /* Free the old data */
3270 if(thisbox->count)
3271 free(thisitem);
3272 DW_MUTEX_UNLOCK;
3273 }
3274
3275 /*
3276 * Pack windows (widgets) into a box from the end (or bottom).
3277 * Parameters: 3300 * Parameters:
3278 * box: Window handle of the box to be packed into. 3301 * box: Window handle of the box to be packed into.
3279 * item: Window handle of the item to be back. 3302 * item: Window handle of the item to be back.
3280 * width: Width in pixels of the item or -1 to be self determined. 3303 * width: Width in pixels of the item or -1 to be self determined.
3281 * height: Height in pixels of the item or -1 to be self determined. 3304 * height: Height in pixels of the item or -1 to be self determined.
3282 * hsize: TRUE if the window (widget) should expand horizontally to fill space given. 3305 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
3283 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 3306 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
3284 * pad: Number of pixels of padding around the item. 3307 * pad: Number of pixels of padding around the item.
3285 */ 3308 */
3286 void API dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad) 3309 void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
3287 { 3310 {
3288 int _locked_by_me = FALSE; 3311 /* 65536 is the table limit on GTK...
3289 DW_MUTEX_LOCK; 3312 * seems like a high enough value we will never hit it here either.
3290 id object = box; 3313 */
3291 DWBox *view = box; 3314 _dw_box_pack(box, item, 65536, width, height, hsize, vsize, pad, "dw_box_pack_start()");
3292 DWBox *this = item; 3315 }
3293 Box *thisbox; 3316
3294 int z; 3317 /*
3295 Item *tmpitem, *thisitem; 3318 * Pack windows (widgets) into a box from the end (or bottom).
3296
3297 /* Query the objects */
3298 if([ object isKindOfClass:[ NSWindow class ] ])
3299 {
3300 NSWindow *window = box;
3301 view = [window contentView];
3302 }
3303 else if([ object isMemberOfClass:[ DWScrollBox class ] ])
3304 {
3305 DWScrollBox *scrollbox = box;
3306 view = [scrollbox box];
3307 }
3308
3309 thisbox = [view box];
3310 thisitem = thisbox->items;
3311 object = item;
3312
3313 /* Query the objects */
3314 if([ object isKindOfClass:[ DWContainer class ] ])
3315 {
3316 DWContainer *cont = item;
3317 this = item = [cont scrollview];
3318 }
3319 else if([ object isKindOfClass:[ DWTree class ] ])
3320 {
3321 DWTree *tree = item;
3322 this = item = [tree scrollview];
3323 }
3324
3325 /* Duplicate the existing data */
3326 tmpitem = malloc(sizeof(Item)*(thisbox->count+1));
3327
3328 for(z=0;z<thisbox->count;z++)
3329 {
3330 tmpitem[z+1] = thisitem[z];
3331 }
3332
3333 /* Sanity checks */
3334 if(vsize && !height)
3335 height = 1;
3336 if(hsize && !width)
3337 width = 1;
3338
3339 /* Fill in the item data appropriately */
3340 if([object isKindOfClass:[DWBox class]] || [object isMemberOfClass:[DWGroupBox class]])
3341 tmpitem[0].type = TYPEBOX;
3342 else
3343 tmpitem[0].type = TYPEITEM;
3344
3345 tmpitem[0].hwnd = item;
3346 tmpitem[0].origwidth = tmpitem[0].width = width;
3347 tmpitem[0].origheight = tmpitem[0].height = height;
3348 tmpitem[0].pad = pad;
3349 if(hsize)
3350 tmpitem[0].hsize = SIZEEXPAND;
3351 else
3352 tmpitem[0].hsize = SIZESTATIC;
3353
3354 if(vsize)
3355 tmpitem[0].vsize = SIZEEXPAND;
3356 else
3357 tmpitem[0].vsize = SIZESTATIC;
3358
3359 thisbox->items = tmpitem;
3360
3361 /* Update the item count */
3362 thisbox->count++;
3363
3364 /* Add the item to the box */
3365 [view addSubview:this];
3366 /* If we are packing a button... */
3367 if([this isMemberOfClass:[DWButton class]])
3368 {
3369 DWButton *button = (DWButton *)this;
3370
3371 /* Save the parent box so radio
3372 * buttons can use it later.
3373 */
3374 [button setParent:view];
3375 }
3376
3377 /* Free the old data */
3378 if(thisbox->count)
3379 free(thisitem);
3380 DW_MUTEX_UNLOCK;
3381 }
3382
3383 /*
3384 * Pack windows (widgets) into a box from the start (or top).
3385 * Parameters: 3319 * Parameters:
3386 * box: Window handle of the box to be packed into. 3320 * box: Window handle of the box to be packed into.
3387 * item: Window handle of the item to be back. 3321 * item: Window handle of the item to be back.
3388 * width: Width in pixels of the item or -1 to be self determined. 3322 * width: Width in pixels of the item or -1 to be self determined.
3389 * height: Height in pixels of the item or -1 to be self determined. 3323 * height: Height in pixels of the item or -1 to be self determined.
3390 * hsize: TRUE if the window (widget) should expand horizontally to fill space given. 3324 * hsize: TRUE if the window (widget) should expand horizontally to fill space given.
3391 * vsize: TRUE if the window (widget) should expand vertically to fill space given. 3325 * vsize: TRUE if the window (widget) should expand vertically to fill space given.
3392 * pad: Number of pixels of padding around the item. 3326 * pad: Number of pixels of padding around the item.
3393 */ 3327 */
3394 void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad) 3328 void API dw_box_pack_end(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
3395 { 3329 {
3396 int _locked_by_me = FALSE; 3330 _dw_box_pack(box, item, 0, width, height, hsize, vsize, pad, "dw_box_pack_end()");
3397 DW_MUTEX_LOCK;
3398 id object = box;
3399 DWBox *view = box;
3400 DWBox *this = item;
3401 Box *thisbox;
3402 int z;
3403 Item *tmpitem, *thisitem;
3404
3405 /* Query the objects */
3406 if([ object isKindOfClass:[ NSWindow class ] ])
3407 {
3408 NSWindow *window = box;
3409 view = [window contentView];
3410 }
3411 else if([ object isMemberOfClass:[ DWScrollBox class ] ])
3412 {
3413 DWScrollBox *scrollbox = box;
3414 view = [scrollbox box];
3415 }
3416
3417 thisbox = [view box];
3418 thisitem = thisbox->items;
3419 object = item;
3420
3421 /* Query the objects */
3422 if([ object isKindOfClass:[ DWContainer class ] ])
3423 {
3424 DWContainer *cont = item;
3425 this = item = [cont scrollview];
3426 }
3427 else if([ object isKindOfClass:[ DWTree class ] ])
3428 {
3429 DWTree *tree = item;
3430 this = item = [tree scrollview];
3431 }
3432
3433 /* Duplicate the existing data */
3434 tmpitem = malloc(sizeof(Item)*(thisbox->count+1));
3435
3436 for(z=0;z<thisbox->count;z++)
3437 {
3438 tmpitem[z] = thisitem[z];
3439 }
3440
3441 /* Sanity checks */
3442 if(vsize && !height)
3443 height = 1;
3444 if(hsize && !width)
3445 width = 1;
3446
3447 /* Fill in the item data appropriately */
3448 if([object isKindOfClass:[DWBox class]] || [object isMemberOfClass:[DWGroupBox class]])
3449 tmpitem[thisbox->count].type = TYPEBOX;
3450 else
3451 tmpitem[thisbox->count].type = TYPEITEM;
3452
3453 tmpitem[thisbox->count].hwnd = item;
3454 tmpitem[thisbox->count].origwidth = tmpitem[thisbox->count].width = width;
3455 tmpitem[thisbox->count].origheight = tmpitem[thisbox->count].height = height;
3456 tmpitem[thisbox->count].pad = pad;
3457 if(hsize)
3458 tmpitem[thisbox->count].hsize = SIZEEXPAND;
3459 else
3460 tmpitem[thisbox->count].hsize = SIZESTATIC;
3461
3462 if(vsize)
3463 tmpitem[thisbox->count].vsize = SIZEEXPAND;
3464 else
3465 tmpitem[thisbox->count].vsize = SIZESTATIC;
3466
3467 thisbox->items = tmpitem;
3468
3469 /* Update the item count */
3470 thisbox->count++;
3471
3472 /* Add the item to the box */
3473 [view addSubview:this];
3474 /* If we are packing a button... */
3475 if([this isMemberOfClass:[DWButton class]])
3476 {
3477 DWButton *button = (DWButton *)this;
3478
3479 /* Save the parent box so radio
3480 * buttons can use it later.
3481 */
3482 [button setParent:view];
3483 }
3484
3485 /* Free the old data */
3486 if(thisbox->count)
3487 free(thisitem);
3488 DW_MUTEX_UNLOCK;
3489 } 3331 }
3490 3332
3491 HWND _button_new(char *text, ULONG cid) 3333 HWND _button_new(char *text, ULONG cid)
3492 { 3334 {
3493 DWButton *button = [[DWButton alloc] init]; 3335 DWButton *button = [[DWButton alloc] init];