source/blender/editors/interface/interface.c

   1 /**
   2  * $Id: interface.c 16882 2008-10-02 12:29:45Z ton $
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * Contributor(s): Blender Foundation 2002-2008, full recode.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include <float.h>
  29 #include <math.h>
  30 #include <string.h>
  31
  32 #include "MEM_guardedalloc.h"
  33
  34 #include "DNA_ID.h"
  35 #include "DNA_listBase.h"
  36 #include "DNA_screen_types.h"
  37 #include "DNA_texture_types.h"
  38 #include "DNA_userdef_types.h"
  39
  40 #include "BLI_arithb.h"
  41 #include "BLI_blenlib.h"
  42 #include "BLI_dynstr.h"
  43
  44 #include "BKE_context.h"
  45 #include "BKE_idprop.h"
  46 #include "BKE_library.h"
  47 #include "BKE_screen.h"
  48 #include "BKE_texture.h"
  49 #include "BKE_utildefines.h"
  50
  51 #include "BIF_gl.h"
  52 #include "BIF_glutil.h"
  53
  54 #include "UI_interface.h"
  55 #include "UI_text.h"
  56
  57 #include "BMF_Api.h"
  58 #ifdef INTERNATIONAL
  59 #include "FTF_Api.h"
  60 #endif
  61
  62 #include "ED_screen.h"
  63
  64 #include "WM_api.h"
  65 #include "WM_types.h"
  66 #include "wm_subwindow.h"
  67 #include "wm_window.h"
  68
  69 #include "RNA_access.h"
  70 #include "RNA_types.h"
  71
  72 #include "interface_intern.h"
  73
  74 /*
  75  * a full doc with API notes can be found in bf-blender/blender/doc/interface_API.txt
  76  *
  77  * uiBlahBlah()         external function
  78  * ui_blah_blah()       internal function
  79  */
  80
  81 static void ui_free_but(const bContext *C, uiBut *but);
  82
  83 /* ************ GLOBALS ************* */
  84
  85 static uiFont UIfont[UI_ARRAY];  // no init needed
  86
  87 /* ************* translation ************** */
  88
  89 int ui_translate_buttons()
  90 {
  91         return (U.transopts & USER_TR_BUTTONS);
  92 }
  93
  94 int ui_translate_menus()
  95 {
  96         return (U.transopts & USER_TR_MENUS);
  97 }
  98
  99 int ui_translate_tooltips()
 100 {
 101         return (U.transopts & USER_TR_TOOLTIPS);
 102 }
 103
 104 /* ************* window matrix ************** */
 105
 106 void ui_block_to_window_fl(const ARegion *ar, uiBlock *block, float *x, float *y)
 107 {
 108         float gx, gy;
 109         int sx, sy, getsizex, getsizey;
 110
 111         getsizex= ar->winrct.xmax-ar->winrct.xmin+1;
 112         getsizey= ar->winrct.ymax-ar->winrct.ymin+1;
 113         sx= ar->winrct.xmin;
 114         sy= ar->winrct.ymin;
 115
 116         gx= *x;
 117         gy= *y;
 118
 119         if(block->panel) {
 120                 gx += block->panel->ofsx;
 121                 gy += block->panel->ofsy;
 122         }
 123
 124         *x= ((float)sx) + ((float)getsizex)*(0.5+ 0.5*(gx*block->winmat[0][0]+ gy*block->winmat[1][0]+ block->winmat[3][0]));
 125         *y= ((float)sy) + ((float)getsizey)*(0.5+ 0.5*(gx*block->winmat[0][1]+ gy*block->winmat[1][1]+ block->winmat[3][1]));
 126 }
 127
 128 void ui_block_to_window(const ARegion *ar, uiBlock *block, int *x, int *y)
 129 {
 130         float fx, fy;
 131
 132         fx= *x;
 133         fy= *y;
 134
 135         ui_block_to_window_fl(ar, block, &fx, &fy);
 136
 137         *x= (int)(fx+0.5f);
 138         *y= (int)(fy+0.5f);
 139 }
 140
 141 void ui_block_to_window_rct(const ARegion *ar, uiBlock *block, rctf *graph, rcti *winr)
 142 {
 143         rctf tmpr;
 144
 145         tmpr= *graph;
 146         ui_block_to_window_fl(ar, block, &tmpr.xmin, &tmpr.ymin);
 147         ui_block_to_window_fl(ar, block, &tmpr.xmax, &tmpr.ymax);
 148
 149         winr->xmin= tmpr.xmin;
 150         winr->ymin= tmpr.ymin;
 151         winr->xmax= tmpr.xmax;
 152         winr->ymax= tmpr.ymax;
 153 }
 154
 155 void ui_window_to_block_fl(const ARegion *ar, uiBlock *block, float *x, float *y)       /* for mouse cursor */
 156 {
 157         float a, b, c, d, e, f, px, py;
 158         int sx, sy, getsizex, getsizey;
 159
 160         getsizex= ar->winrct.xmax-ar->winrct.xmin+1;
 161         getsizey= ar->winrct.ymax-ar->winrct.ymin+1;
 162         sx= ar->winrct.xmin;
 163         sy= ar->winrct.ymin;
 164
 165         a= .5*((float)getsizex)*block->winmat[0][0];
 166         b= .5*((float)getsizex)*block->winmat[1][0];
 167         c= .5*((float)getsizex)*(1.0+block->winmat[3][0]);
 168
 169         d= .5*((float)getsizey)*block->winmat[0][1];
 170         e= .5*((float)getsizey)*block->winmat[1][1];
 171         f= .5*((float)getsizey)*(1.0+block->winmat[3][1]);
 172
 173         px= *x - sx;
 174         py= *y - sy;
 175
 176         *y=  (a*(py-f) + d*(c-px))/(a*e-d*b);
 177         *x= (px- b*(*y)- c)/a;
 178
 179         if(block->panel) {
 180                 *x -= block->panel->ofsx;
 181                 *y -= block->panel->ofsy;
 182         }
 183 }
 184
 185 void ui_window_to_block(const ARegion *ar, uiBlock *block, int *x, int *y)
 186 {
 187         float fx, fy;
 188
 189         fx= *x;
 190         fy= *y;
 191
 192         ui_window_to_block_fl(ar, block, &fx, &fy);
 193
 194         *x= (int)(fx+0.5f);
 195         *y= (int)(fy+0.5f);
 196 }
 197
 198 void ui_window_to_region(const ARegion *ar, int *x, int *y)
 199 {
 200         *x-= ar->winrct.xmin;
 201         *y-= ar->winrct.ymin;
 202 }
 203
 204 /* ******************* block calc ************************* */
 205
 206 /* only for pulldowns */
 207 void uiTextBoundsBlock(uiBlock *block, int addval)
 208 {
 209         uiBut *bt;
 210         int i = 0, j, x1addval= 0, nextcol;
 211
 212         bt= block->buttons.first;
 213         while(bt) {
 214                 if(bt->type!=SEPR) {
 215                         int transopts= ui_translate_buttons();
 216                         if(bt->type==TEX || bt->type==IDPOIN) transopts= 0;
 217                         j= UI_GetStringWidth(bt->font, bt->drawstr, transopts);
 218
 219                         if(j > i) i = j;
 220                 }
 221                 bt= bt->next;
 222         }
 223
 224         /* cope with multi collumns */
 225         bt= block->buttons.first;
 226         while(bt) {
 227                 if(bt->next && bt->x1 < bt->next->x1)
 228                         nextcol= 1;
 229                 else nextcol= 0;
 230
 231                 bt->x1 = x1addval;
 232                 bt->x2 = bt->x1 + i + addval;
 233
 234                 ui_check_but(bt);       // clips text again
 235
 236                 if(nextcol)
 237                         x1addval+= i + addval;
 238
 239                 bt= bt->next;
 240         }
 241 }
 242
 243 void uiBoundsBlock(uiBlock *block, int addval)
 244 {
 245         uiBut *bt;
 246         int xof;
 247
 248         if(block==NULL)
 249                 return;
 250
 251         if(block->buttons.first==NULL) {
 252                 if(block->panel) {
 253                         block->minx= 0.0; block->maxx= block->panel->sizex;
 254                         block->miny= 0.0; block->maxy= block->panel->sizey;
 255                 }
 256         }
 257         else {
 258
 259                 block->minx= block->miny= 10000;
 260                 block->maxx= block->maxy= -10000;
 261
 262                 bt= block->buttons.first;
 263                 while(bt) {
 264                         if(bt->x1 < block->minx) block->minx= bt->x1;
 265                         if(bt->y1 < block->miny) block->miny= bt->y1;
 266
 267                         if(bt->x2 > block->maxx) block->maxx= bt->x2;
 268                         if(bt->y2 > block->maxy) block->maxy= bt->y2;
 269
 270                         bt= bt->next;
 271                 }
 272
 273                 block->minx -= addval;
 274                 block->miny -= addval;
 275                 block->maxx += addval;
 276                 block->maxy += addval;
 277         }
 278
 279         /* hardcoded exception... but that one is annoying with larger safety */
 280         bt= block->buttons.first;
 281         if(bt && strncmp(bt->str, "ERROR", 5)==0) xof= 10;
 282         else xof= 40;
 283
 284         block->safety.xmin= block->minx-xof;
 285         block->safety.ymin= block->miny-xof;
 286         block->safety.xmax= block->maxx+xof;
 287         block->safety.ymax= block->maxy+xof;
 288 }
 289
 290 void uiBlockTranslate(uiBlock *block, int x, int y)
 291 {
 292         uiBut *bt;
 293
 294         for(bt= block->buttons.first; bt; bt=bt->next) {
 295                 bt->x1 += x;
 296                 bt->y1 += y;
 297                 bt->x2 += x;
 298                 bt->y2 += y;
 299         }
 300
 301         block->minx += x;
 302         block->miny += y;
 303         block->maxx += x;
 304         block->maxy += y;
 305 }
 306
 307 void uiBlockOrigin(uiBlock *block)
 308 {
 309         uiBut *bt;
 310         int minx= 10000, miny= 10000;
 311
 312         for(bt= block->buttons.first; bt; bt=bt->next) {
 313                 if(bt->x1 < minx) minx= bt->x1;
 314                 if(bt->y1 < miny) miny= bt->y1;
 315         }
 316
 317         uiBlockTranslate(block, -minx, -miny);
 318 }
 319
 320 void ui_autofill(uiBlock *block)
 321 {
 322         uiBut *but;
 323         float *maxw, *maxh, startx = 0, starty, height = 0;
 324         float totmaxh;
 325         int rows=0, /*  cols=0, */ i, lasti;
 326
 327         /* first count rows */
 328         but= block->buttons.last;
 329         rows= but->x1+1;
 330
 331         /* calculate max width / height for each row */
 332         maxw= MEM_callocN(sizeof(float)*rows, "maxw");
 333         maxh= MEM_callocN(sizeof(float)*rows, "maxh");
 334         but= block->buttons.first;
 335         while(but) {
 336                 i= but->x1;
 337                 if( maxh[i] < but->y2) maxh[i]= but->y2;
 338                 maxw[i] += but->x2;
 339                 but= but->next;
 340         }
 341
 342         totmaxh= 0.0;
 343         for(i=0; i<rows; i++) totmaxh+= maxh[i];
 344
 345         /* apply widths/heights */
 346         starty= block->maxy;
 347         but= block->buttons.first;
 348         lasti= -1;
 349         while(but) {
 350                 // signal for aligning code
 351                 but->flag |= UI_BUT_ALIGN_DOWN;
 352
 353                 i= but->x1;
 354
 355                 if(i!=lasti) {
 356                         startx= block->minx;
 357                         height= (maxh[i]*(block->maxy-block->miny))/totmaxh;
 358                         starty-= height;
 359                         lasti= i;
 360                 }
 361
 362                 but->y1= starty+but->aspect;
 363                 but->y2= but->y1+height-but->aspect;
 364
 365                 but->x2= (but->x2*(block->maxx-block->minx))/maxw[i];
 366                 but->x1= startx+but->aspect;
 367
 368                 startx+= but->x2;
 369                 but->x2+= but->x1-but->aspect;
 370
 371                 ui_check_but(but);
 372
 373                 but= but->next;
 374         }
 375
 376         uiBlockEndAlign(block);
 377
 378         MEM_freeN(maxw); MEM_freeN(maxh);
 379         block->autofill= 0;
 380 }
 381
 382 /* ************** LINK LINE DRAWING  ************* */
 383
 384 /* link line drawing is not part of buttons or theme.. so we stick with it here */
 385
 386 static void ui_draw_linkline(uiBut *but, uiLinkLine *line)
 387 {
 388         float vec1[2], vec2[2];
 389
 390         if(line->from==NULL || line->to==NULL) return;
 391
 392         vec1[0]= (line->from->x1+line->from->x2)/2.0;
 393         vec1[1]= (line->from->y1+line->from->y2)/2.0;
 394         vec2[0]= (line->to->x1+line->to->x2)/2.0;
 395         vec2[1]= (line->to->y1+line->to->y2)/2.0;
 396
 397         if(line->flag & UI_SELECT) UI_ThemeColorShade(but->themecol, 80);
 398         else glColor3ub(0,0,0);
 399         fdrawline(vec1[0], vec1[1], vec2[0], vec2[1]);
 400 }
 401
 402 static void ui_draw_links(uiBlock *block)
 403 {
 404         uiBut *but;
 405         uiLinkLine *line;
 406
 407         but= block->buttons.first;
 408         while(but) {
 409                 if(but->type==LINK && but->link) {
 410                         line= but->link->lines.first;
 411                         while(line) {
 412                                 ui_draw_linkline(but, line);
 413                                 line= line->next;
 414                         }
 415                 }
 416                 but= but->next;
 417         }
 418 }
 419
 420 /* ************** BLOCK ENDING FUNCTION ************* */
 421
 422 static int ui_but_equals_old(uiBut *but, uiBut *oldbut)
 423 {
 424         /* various properties are being compared here, hopfully sufficient
 425          * to catch all cases, but it is simple to add more checks later */
 426         if(but->retval != oldbut->retval) return 0;
 427         if(but->poin != oldbut->poin || but->pointype != oldbut->pointype) return 0;
 428         if(but->rnapoin.data != oldbut->rnapoin.data) return 0;
 429         if(but->rnaprop != oldbut->rnaprop)
 430         if(but->rnaindex != oldbut->rnaindex) return 0;
 431         if(but->func != oldbut->func) return 0;
 432         if(but->func_arg1 != oldbut->func_arg1) return 0;
 433         if(but->func_arg2 != oldbut->func_arg2) return 0;
 434
 435         return 1;
 436 }
 437
 438 static int ui_but_update_from_old_block(const bContext *C, uiBlock *block, uiBut *but)
 439 {
 440         uiBlock *oldblock;
 441         uiBut *oldbut;
 442         int found= 0;
 443
 444         oldblock= block->oldblock;
 445         if(!oldblock)
 446                 return found;
 447
 448         for(oldbut=oldblock->buttons.first; oldbut; oldbut=oldbut->next) {
 449                 if(ui_but_equals_old(oldbut, but)) {
 450                         if(oldbut->active) {
 451                                 but->flag= oldbut->flag;
 452                                 but->active= oldbut->active;
 453                                 but->pos= oldbut->pos;
 454                                 but->editstr= oldbut->editstr;
 455                                 but->editval= oldbut->editval;
 456                                 but->editvec= oldbut->editvec;
 457                                 but->editcoba= oldbut->editcoba;
 458                                 but->editcumap= oldbut->editcumap;
 459                                 but->selsta= oldbut->selsta;
 460                                 but->selend= oldbut->selend;
 461                                 found= 1;
 462
 463                                 oldbut->active= NULL;
 464                         }
 465
 466                         /* ensures one button can get activated, and in case the buttons
 467                          * draw are the same this gives O(1) lookup for each button */
 468                         BLI_remlink(&oldblock->buttons, oldbut);
 469                         ui_free_but(C, oldbut);
 470
 471                         break;
 472                 }
 473         }
 474
 475         return found;
 476 }
 477
 478 void uiEndBlock(const bContext *C, uiBlock *block)
 479 {
 480         uiBut *but;
 481
 482         /* inherit flags from 'old' buttons that was drawn here previous, based
 483          * on matching buttons, we need this to make button event handling non
 484          * blocking, while still alowing buttons to be remade each redraw as it
 485          * is expected by blender code */
 486         for(but=block->buttons.first; but; but=but->next)
 487                 if(ui_but_update_from_old_block(C, block, but))
 488                         ui_check_but(but);
 489
 490         if(block->oldblock) {
 491                 block->auto_open= block->oldblock->auto_open;
 492                 block->auto_open_last= block->oldblock->auto_open_last;
 493                 block->tooltipdisabled= block->oldblock->tooltipdisabled;
 494
 495                 block->oldblock= NULL;
 496         }
 497
 498         /* handle pending stuff */
 499         if(block->autofill) ui_autofill(block);
 500         if(block->minx==0.0 && block->maxx==0.0) uiBoundsBlock(block, 0);
 501         if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block);
 502 }
 503
 504 /* ************** BLOCK DRAWING FUNCTION ************* */
 505
 506 void uiDrawBlock(const bContext *C, uiBlock *block)
 507 {
 508         uiBut *but;
 509
 510         /* we set this only once */
 511         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 512
 513         if(block->flag & UI_BLOCK_LOOP)
 514                 uiDrawMenuBox(block->minx, block->miny, block->maxx, block->maxy, block->flag);
 515         else if(block->panel)
 516                 ui_draw_panel(CTX_wm_region(C), block);
 517
 518         if(block->drawextra) block->drawextra(C, block);
 519
 520         for (but= block->buttons.first; but; but= but->next)
 521                 ui_draw_but(but);
 522
 523         ui_draw_links(block);
 524 }
 525
 526 /* ************* EVENTS ************* */
 527
 528 static void ui_is_but_sel(uiBut *but)
 529 {
 530         double value;
 531         int lvalue;
 532         short push=0, true=1;
 533
 534         value= ui_get_but_val(but);
 535
 536         if( but->type==TOGN  || but->type==ICONTOGN) true= 0;
 537
 538         if( but->bit ) {
 539                 lvalue= (int)value;
 540                 if( BTST(lvalue, (but->bitnr)) ) push= true;
 541                 else push= !true;
 542         }
 543         else {
 544                 switch(but->type) {
 545                 case BUT:
 546                         push= 2;
 547                         break;
 548                 case KEYEVT:
 549                         if (value==-1) push= 1;
 550                         break;
 551                 case TOG:
 552                 case TOGR:
 553                 case TOG3:
 554                 case BUT_TOGDUAL:
 555                 case ICONTOG:
 556                         if(value!=but->min) push= 1;
 557                         break;
 558                 case ICONTOGN:
 559                 case TOGN:
 560                         if(value==0.0) push= 1;
 561                         break;
 562                 case ROW:
 563                         if(value == but->max) push= 1;
 564                         break;
 565                 case COL:
 566                         push= 1;
 567                         break;
 568                 default:
 569                         push= 2;
 570                         break;
 571                 }
 572         }
 573
 574         if(push==2);
 575         else if(push==1) but->flag |= UI_SELECT;
 576         else but->flag &= ~UI_SELECT;
 577 }
 578
 579 /* XXX 2.50 no links supported yet */
 580
 581 #if 0
 582 static uiBut *ui_get_valid_link_button(uiBlock *block, uiBut *but, short *mval)
 583 {
 584         uiBut *bt;
 585
 586                 /* find button to link to */
 587         for (bt= block->buttons.first; bt; bt= bt->next)
 588                 if(bt!=but && uibut_contains_pt(bt, mval))
 589                         break;
 590
 591         if (bt) {
 592                 if (but->type==LINK && bt->type==INLINK) {
 593                         if( but->link->tocode == (int)bt->min ) {
 594                                 return bt;
 595                         }
 596                 }
 597                 else if(but->type==INLINK && bt->type==LINK) {
 598                         if( bt->link->tocode == (int)but->min ) {
 599                                 return bt;
 600                         }
 601                 }
 602         }
 603
 604         return NULL;
 605 }
 606
 607 static int ui_is_a_link(uiBut *from, uiBut *to)
 608 {
 609         uiLinkLine *line;
 610         uiLink *link;
 611
 612         link= from->link;
 613         if(link) {
 614                 line= link->lines.first;
 615                 while(line) {
 616                         if(line->from==from && line->to==to) return 1;
 617                         line= line->next;
 618                 }
 619         }
 620         return 0;
 621 }
 622
 623 static uiBut *ui_find_inlink(uiBlock *block, void *poin)
 624 {
 625         uiBut *but;
 626
 627         but= block->buttons.first;
 628         while(but) {
 629                 if(but->type==INLINK) {
 630                         if(but->poin == poin) return but;
 631                 }
 632                 but= but->next;
 633         }
 634         return NULL;
 635 }
 636
 637 static void ui_add_link_line(ListBase *listb, uiBut *but, uiBut *bt)
 638 {
 639         uiLinkLine *line;
 640
 641         line= MEM_callocN(sizeof(uiLinkLine), "linkline");
 642         BLI_addtail(listb, line);
 643         line->from= but;
 644         line->to= bt;
 645 }
 646
 647 uiBut *uiFindInlink(uiBlock *block, void *poin)
 648 {
 649         return ui_find_inlink(block, poin);
 650 }
 651
 652 void uiComposeLinks(uiBlock *block)
 653 {
 654         uiBut *but, *bt;
 655         uiLink *link;
 656         void ***ppoin;
 657         int a;
 658
 659         but= block->buttons.first;
 660         while(but) {
 661                 if(but->type==LINK) {
 662                         link= but->link;
 663
 664                         /* for all pointers in the array */
 665                         if(link) {
 666                                 if(link->ppoin) {
 667                                         ppoin= link->ppoin;
 668                                         for(a=0; a < *(link->totlink); a++) {
 669                                                 bt= ui_find_inlink(block, (*ppoin)[a] );
 670                                                 if(bt) {
 671                                                         ui_add_link_line(&link->lines, but, bt);
 672                                                 }
 673                                         }
 674                                 }
 675                                 else if(link->poin) {
 676                                         bt= ui_find_inlink(block, *(link->poin) );
 677                                         if(bt) {
 678                                                 ui_add_link_line(&link->lines, but, bt);
 679                                         }
 680                                 }
 681                         }
 682                 }
 683                 but= but->next;
 684         }
 685 }
 686
 687 static void ui_add_link(uiBut *from, uiBut *to)
 688 {
 689         /* in 'from' we have to add a link to 'to' */
 690         uiLink *link;
 691         void **oldppoin;
 692         int a;
 693
 694         if(ui_is_a_link(from, to)) {
 695                 printf("already exists\n");
 696                 return;
 697         }
 698
 699         link= from->link;
 700
 701         /* are there more pointers allowed? */
 702         if(link->ppoin) {
 703                 oldppoin= *(link->ppoin);
 704
 705                 (*(link->totlink))++;
 706                 *(link->ppoin)= MEM_callocN( *(link->totlink)*sizeof(void *), "new link");
 707
 708                 for(a=0; a< (*(link->totlink))-1; a++) {
 709                         (*(link->ppoin))[a]= oldppoin[a];
 710                 }
 711                 (*(link->ppoin))[a]= to->poin;
 712
 713                 if(oldppoin) MEM_freeN(oldppoin);
 714         }
 715         else {
 716                 *(link->poin)= to->poin;
 717         }
 718
 719 }
 720
 721 static int ui_do_but_LINK(uiBlock *block, uiBut *but)
 722 {
 723         /*
 724          * This button only visualizes, the dobutton mode
 725          * can add a new link, but then the whole system
 726          * should be redrawn/initialized.
 727          *
 728          */
 729         uiBut *bt=0, *bto=NULL;
 730         short sval[2], mval[2], mvalo[2], first= 1;
 731
 732         uiGetMouse(curarea->win, sval);
 733         mvalo[0]= sval[0];
 734         mvalo[1]= sval[1];
 735
 736         while (get_mbut() & L_MOUSE) {
 737                 uiGetMouse(curarea->win, mval);
 738
 739                 if(mval[0]!=mvalo[0] || mval[1]!=mvalo[1] || first) {
 740                                 /* clear completely, because of drawbuttons */
 741                         bt= ui_get_valid_link_button(block, but, mval);
 742                         if(bt) {
 743                                 bt->flag |= UI_ACTIVE;
 744                                 ui_draw_but(bt);
 745                         }
 746                         if(bto && bto!=bt) {
 747                                 bto->flag &= ~UI_ACTIVE;
 748                                 ui_draw_but(bto);
 749                         }
 750                         bto= bt;
 751
 752                         if (!first) {
 753                                 glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]);
 754                         }
 755                         glutil_draw_front_xor_line(sval[0], sval[1], mval[0], mval[1]);
 756
 757                         mvalo[0]= mval[0];
 758                         mvalo[1]= mval[1];
 759
 760                         first= 0;
 761                 }
 762                 else UI_wait_for_statechange();
 763         }
 764
 765         if (!first) {
 766                 glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]);
 767         }
 768
 769         if(bt) {
 770                 if(but->type==LINK) ui_add_link(but, bt);
 771                 else ui_add_link(bt, but);
 772
 773                 scrarea_queue_winredraw(curarea);
 774         }
 775
 776         return 0;
 777 }
 778 #endif
 779
 780 /* ************************************************ */
 781
 782 void uiBlockSetButLock(uiBlock *block, int val, char *lockstr)
 783 {
 784         block->lock |= val;
 785         if(val) block->lockstr= lockstr;
 786 }
 787
 788 void uiBlockClearButLock(uiBlock *block)
 789 {
 790         block->lock= 0;
 791         block->lockstr= NULL;
 792 }
 793
 794 /* *************************************************************** */
 795
 796 /* XXX 2.50 no button editing */
 797
 798 #if 0
 799 static void setup_file(uiBlock *block)
 800 {
 801         uiBut *but;
 802         FILE *fp;
 803
 804         fp= fopen("butsetup","w");
 805         if(fp==NULL);
 806         else {
 807                 but= block->buttons.first;
 808                 while(but) {
 809                         ui_check_but(but);
 810                         fprintf(fp,"%d,%d,%d,%d   %s %s\n", (int)but->x1, (int)but->y1, (int)( but->x2-but->x1), (int)(but->y2-but->y1), but->str, but->tip);
 811                         but= but->next;
 812                 }
 813                 fclose(fp);
 814         }
 815 }
 816
 817
 818 static void edit_but(uiBlock *block, uiBut *but, uiEvent *uevent)
 819 {
 820         short dx, dy, mval[2], mvalo[2], didit=0;
 821
 822         getmouseco_sc(mvalo);
 823         while(TRUE) {
 824                 if( !(get_mbut() & L_MOUSE) ) break;
 825
 826                 getmouseco_sc(mval);
 827                 dx= (mval[0]-mvalo[0]);
 828                 dy= (mval[1]-mvalo[1]);
 829
 830                 if(dx!=0 || dy!=0) {
 831                         mvalo[0]= mval[0];
 832                         mvalo[1]= mval[1];
 833
 834                         cpack(0xc0c0c0);
 835                         glRectf(but->x1-2, but->y1-2, but->x2+2, but->y2+2);
 836
 837                         if((uevent->qual & LR_SHIFTKEY)==0) {
 838                                 but->x1 += dx;
 839                                 but->y1 += dy;
 840                         }
 841                         but->x2 += dx;
 842                         but->y2 += dy;
 843
 844                         ui_draw_but(but);
 845                         ui_block_flush_back(but->block);
 846                         didit= 1;
 847
 848                 }
 849                 /* idle for this poor code */
 850                 else PIL_sleep_ms(30);
 851         }
 852         if(didit) setup_file(block);
 853 }
 854 #endif
 855
 856 /* XXX 2.50 no links supported yet */
 857 #if 0
 858 static void ui_delete_active_linkline(uiBlock *block)
 859 {
 860         uiBut *but;
 861         uiLink *link;
 862         uiLinkLine *line, *nline;
 863         int a, b;
 864
 865         but= block->buttons.first;
 866         while(but) {
 867                 if(but->type==LINK && but->link) {
 868                         line= but->link->lines.first;
 869                         while(line) {
 870
 871                                 nline= line->next;
 872
 873                                 if(line->flag & UI_SELECT) {
 874                                         BLI_remlink(&but->link->lines, line);
 875
 876                                         link= line->from->link;
 877
 878                                         /* are there more pointers allowed? */
 879                                         if(link->ppoin) {
 880
 881                                                 if(*(link->totlink)==1) {
 882                                                         *(link->totlink)= 0;
 883                                                         MEM_freeN(*(link->ppoin));
 884                                                         *(link->ppoin)= NULL;
 885                                                 }
 886                                                 else {
 887                                                         b= 0;
 888                                                         for(a=0; a< (*(link->totlink)); a++) {
 889
 890                                                                 if( (*(link->ppoin))[a] != line->to->poin ) {
 891                                                                         (*(link->ppoin))[b]= (*(link->ppoin))[a];
 892                                                                         b++;
 893                                                                 }
 894                                                         }
 895                                                         (*(link->totlink))--;
 896                                                 }
 897                                         }
 898                                         else {
 899                                                 *(link->poin)= NULL;
 900                                         }
 901
 902                                         MEM_freeN(line);
 903                                 }
 904                                 line= nline;
 905                         }
 906                 }
 907                 but= but->next;
 908         }
 909
 910         /* temporal! these buttons can be everywhere... */
 911         allqueue(REDRAWBUTSLOGIC, 0);
 912 }
 913
 914 static void ui_do_active_linklines(uiBlock *block, short *mval)
 915 {
 916         uiBut *but;
 917         uiLinkLine *line, *act= NULL;
 918         float mindist= 12.0, fac, v1[2], v2[2], v3[3];
 919         int foundone= 0;
 920
 921         if(mval) {
 922                 v1[0]= mval[0];
 923                 v1[1]= mval[1];
 924
 925                 /* find a line close to the mouse */
 926                 but= block->buttons.first;
 927                 while(but) {
 928                         if(but->type==LINK && but->link) {
 929                                 foundone= 1;
 930                                 line= but->link->lines.first;
 931                                 while(line) {
 932                                         v2[0]= line->from->x2;
 933                                         v2[1]= (line->from->y1+line->from->y2)/2.0;
 934                                         v3[0]= line->to->x1;
 935                                         v3[1]= (line->to->y1+line->to->y2)/2.0;
 936
 937                                         fac= PdistVL2Dfl(v1, v2, v3);
 938                                         if(fac < mindist) {
 939                                                 mindist= fac;
 940                                                 act= line;
 941                                         }
 942                                         line= line->next;
 943                                 }
 944                         }
 945                         but= but->next;
 946                 }
 947         }
 948
 949         /* check for a 'found one' to prevent going to 'frontbuffer' mode.
 950                 this slows done gfx quite some, and at OSX the 'finish' forces a swapbuffer */
 951         if(foundone) {
 952                 glDrawBuffer(GL_FRONT);
 953
 954                 /* draw */
 955                 but= block->buttons.first;
 956                 while(but) {
 957                         if(but->type==LINK && but->link) {
 958                                 line= but->link->lines.first;
 959                                 while(line) {
 960                                         if(line==act) {
 961                                                 if((line->flag & UI_SELECT)==0) {
 962                                                         line->flag |= UI_SELECT;
 963                                                         ui_draw_linkline(but, line);
 964                                                 }
 965                                         }
 966                                         else if(line->flag & UI_SELECT) {
 967                                                 line->flag &= ~UI_SELECT;
 968                                                 ui_draw_linkline(but, line);
 969                                         }
 970                                         line= line->next;
 971                                 }
 972                         }
 973                         but= but->next;
 974                 }
 975                 bglFlush();
 976                 glDrawBuffer(GL_BACK);
 977         }
 978 }
 979 #endif
 980
 981 /* ******************************************************* */
 982
 983 /* XXX 2.50 no screendump supported yet */
 984
 985 #if 0
 986 /* nasty but safe way to store screendump rect */
 987 static int scr_x=0, scr_y=0, scr_sizex=0, scr_sizey=0;
 988
 989 static void ui_set_screendump_bbox(uiBlock *block)
 990 {
 991         if(block) {
 992                 scr_x= block->minx;
 993                 scr_y= block->miny;
 994                 scr_sizex= block->maxx - block->minx;
 995                 scr_sizey= block->maxy - block->miny;
 996         }
 997         else {
 998                 scr_sizex= scr_sizey= 0;
 999         }
1000 }
1001
1002 /* used for making screenshots for menus, called in screendump.c */
1003 int uiIsMenu(int *x, int *y, int *sizex, int *sizey)
1004 {
1005         if(scr_sizex!=0 && scr_sizey!=0) {
1006                 *x= scr_x;
1007                 *y= scr_y;
1008                 *sizex= scr_sizex;
1009                 *sizey= scr_sizey;
1010                 return 1;
1011         }
1012
1013         return 0;
1014 }
1015 #endif
1016
1017 /* *********************** data get/set ***********************
1018  * this either works with the pointed to data, or can work with
1019  * an edit override pointer while dragging for example */
1020
1021 /* for buttons pointing to color for example */
1022 void ui_get_but_vectorf(uiBut *but, float *vec)
1023 {
1024         PropertyRNA *prop;
1025         int a, tot;
1026
1027         if(but->editvec) {
1028                 VECCOPY(vec, but->editvec);
1029                 return;
1030         }
1031
1032         if(but->rnaprop) {
1033                 prop= but->rnaprop;
1034
1035                 vec[0]= vec[1]= vec[2]= 0.0f;
1036
1037                 if(RNA_property_type(&but->rnapoin, prop) == PROP_FLOAT) {
1038                         tot= RNA_property_array_length(&but->rnapoin, prop);
1039                         tot= MIN2(tot, 3);
1040
1041                         for(a=0; a<tot; a++)
1042                                 vec[a]= RNA_property_float_get_array(&but->rnapoin, prop, a);
1043                 }
1044         }
1045         else if(but->pointype == CHA) {
1046                 char *cp= (char *)but->poin;
1047                 vec[0]= ((float)cp[0])/255.0;
1048                 vec[1]= ((float)cp[1])/255.0;
1049                 vec[2]= ((float)cp[2])/255.0;
1050         }
1051         else if(but->pointype == FLO) {
1052                 float *fp= (float *)but->poin;
1053                 VECCOPY(vec, fp);
1054         }
1055 }
1056
1057 /* for buttons pointing to color for example */
1058 void ui_set_but_vectorf(uiBut *but, float *vec)
1059 {
1060         PropertyRNA *prop;
1061         int a, tot;
1062
1063         if(but->editvec) {
1064                 VECCOPY(but->editvec, vec);
1065                 return;
1066         }
1067
1068         if(but->rnaprop) {
1069                 prop= but->rnaprop;
1070
1071                 if(RNA_property_type(&but->rnapoin, prop) == PROP_FLOAT) {
1072                         tot= RNA_property_array_length(&but->rnapoin, prop);
1073                         tot= MIN2(tot, 3);
1074
1075                         for(a=0; a<tot; a++)
1076                                 RNA_property_float_set_array(&but->rnapoin, prop, a, vec[a]);
1077                 }
1078         }
1079         else if(but->pointype == CHA) {
1080                 char *cp= (char *)but->poin;
1081                 cp[0]= (char)(0.5 +vec[0]*255.0);
1082                 cp[1]= (char)(0.5 +vec[1]*255.0);
1083                 cp[2]= (char)(0.5 +vec[2]*255.0);
1084         }
1085         else if(but->pointype == FLO) {
1086                 float *fp= (float *)but->poin;
1087                 VECCOPY(fp, vec);
1088         }
1089 }
1090
1091 int ui_is_but_float(uiBut *but)
1092 {
1093         if(but->pointype==FLO && but->poin)
1094                 return 1;
1095
1096         if(but->rnaprop && RNA_property_type(&but->rnapoin, but->rnaprop) == PROP_FLOAT)
1097                 return 1;
1098
1099         return 0;
1100 }
1101
1102 double ui_get_but_val(uiBut *but)
1103 {
1104         PropertyRNA *prop;
1105         double value = 0.0;
1106
1107         if(but->editval) { return *(but->editval); }
1108         if(but->poin==NULL && but->rnapoin.data==NULL) return 0.0;
1109
1110         if(but->rnaprop) {
1111                 prop= but->rnaprop;
1112
1113                 switch(RNA_property_type(&but->rnapoin, prop)) {
1114                         case PROP_BOOLEAN:
1115                                 if(RNA_property_array_length(&but->rnapoin, prop))
1116                                         value= RNA_property_boolean_get_array(&but->rnapoin, prop, but->rnaindex);
1117                                 else
1118                                         value= RNA_property_boolean_get(&but->rnapoin, prop);
1119                                 break;
1120                         case PROP_INT:
1121                                 if(RNA_property_array_length(&but->rnapoin, prop))
1122                                         value= RNA_property_int_get_array(&but->rnapoin, prop, but->rnaindex);
1123                                 else
1124                                         value= RNA_property_int_get(&but->rnapoin, prop);
1125                                 break;
1126                         case PROP_FLOAT:
1127                                 if(RNA_property_array_length(&but->rnapoin, prop))
1128                                         value= RNA_property_float_get_array(&but->rnapoin, prop, but->rnaindex);
1129                                 else
1130                                         value= RNA_property_float_get(&but->rnapoin, prop);
1131                                 break;
1132                         case PROP_ENUM:
1133                                 value= RNA_property_enum_get(&but->rnapoin, prop);
1134                                 break;
1135                         default:
1136                                 value= 0.0;
1137                                 break;
1138                 }
1139         }
1140         else if(but->type== HSVSLI) {
1141                 float h, s, v, *fp;
1142
1143                 fp= (but->editvec)? but->editvec: (float *)but->poin;
1144                 rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v);
1145
1146                 switch(but->str[0]) {
1147                         case 'H': value= h; break;
1148                         case 'S': value= s; break;
1149                         case 'V': value= v; break;
1150                 }
1151         }
1152         else if( but->pointype == CHA ) {
1153                 value= *(char *)but->poin;
1154         }
1155         else if( but->pointype == SHO ) {
1156                 value= *(short *)but->poin;
1157         }
1158         else if( but->pointype == INT ) {
1159                 value= *(int *)but->poin;
1160         }
1161         else if( but->pointype == FLO ) {
1162                 value= *(float *)but->poin;
1163         }
1164
1165         return value;
1166 }
1167
1168 void ui_set_but_val(uiBut *but, double value)
1169 {
1170         PropertyRNA *prop;
1171
1172         /* value is a hsv value: convert to rgb */
1173         if(but->rnaprop) {
1174                 prop= but->rnaprop;
1175
1176                 if(RNA_property_editable(&but->rnapoin, prop)) {
1177                         switch(RNA_property_type(&but->rnapoin, prop)) {
1178                                 case PROP_BOOLEAN:
1179                                         if(RNA_property_array_length(&but->rnapoin, prop))
1180                                                 RNA_property_boolean_set_array(&but->rnapoin, prop, but->rnaindex, value);
1181                                         else
1182                                                 RNA_property_boolean_set(&but->rnapoin, prop, value);
1183                                         break;
1184                                 case PROP_INT:
1185                                         if(RNA_property_array_length(&but->rnapoin, prop))
1186                                                 RNA_property_int_set_array(&but->rnapoin, prop, but->rnaindex, value);
1187                                         else
1188                                                 RNA_property_int_set(&but->rnapoin, prop, value);
1189                                         break;
1190                                 case PROP_FLOAT:
1191                                         if(RNA_property_array_length(&but->rnapoin, prop))
1192                                                 RNA_property_float_set_array(&but->rnapoin, prop, but->rnaindex, value);
1193                                         else
1194                                                 RNA_property_float_set(&but->rnapoin, prop, value);
1195                                         break;
1196                                 case PROP_ENUM:
1197                                         RNA_property_enum_set(&but->rnapoin, prop, value);
1198                                         break;
1199                                 default:
1200                                         break;
1201                         }
1202                 }
1203         }
1204         else if(but->pointype==0);
1205         else if(but->type==HSVSLI ) {
1206                 float h, s, v, *fp;
1207
1208                 fp= (but->editvec)? but->editvec: (float *)but->poin;
1209                 rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v);
1210
1211                 switch(but->str[0]) {
1212                 case 'H': h= value; break;
1213                 case 'S': s= value; break;
1214                 case 'V': v= value; break;
1215                 }
1216
1217                 hsv_to_rgb(h, s, v, fp, fp+1, fp+2);
1218
1219         }
1220         else {
1221                 /* first do rounding */
1222                 if(but->pointype==CHA)
1223                         value= (char)floor(value+0.5);
1224                 else if(but->pointype==SHO ) {
1225                         /* gcc 3.2.1 seems to have problems
1226                          * casting a double like 32772.0 to
1227                          * a short so we cast to an int, then
1228                          to a short */
1229                         int gcckludge;
1230                         gcckludge = (int) floor(value+0.5);
1231                         value= (short)gcckludge;
1232                 }
1233                 else if(but->pointype==INT )
1234                         value= (int)floor(value+0.5);
1235                 else if(but->pointype==FLO ) {
1236                         float fval= (float)value;
1237                         if(fval>= -0.00001f && fval<= 0.00001f) fval= 0.0f;     /* prevent negative zero */
1238                         value= fval;
1239                 }
1240
1241                 /* then set value with possible edit override */
1242                 if(but->editval)
1243                         *but->editval= value;
1244                 else if(but->pointype==CHA)
1245                         *((char *)but->poin)= (char)value;
1246                 else if(but->pointype==SHO)
1247                         *((short *)but->poin)= (short)value;
1248                 else if(but->pointype==INT)
1249                         *((int *)but->poin)= (int)value;
1250                 else if(but->pointype==FLO)
1251                         *((float *)but->poin)= (float)value;
1252         }
1253
1254         /* update select flag */
1255         ui_is_but_sel(but);
1256 }
1257
1258 void ui_get_but_string(uiBut *but, char *str, int maxlen)
1259 {
1260         if(but->rnaprop) {
1261                 char *buf;
1262
1263                 buf= RNA_property_string_get_alloc(&but->rnapoin, but->rnaprop, str, maxlen);
1264
1265                 if(buf != str) {
1266                         /* string was too long, we have to truncate */
1267                         BLI_strncpy(str, buf, maxlen);
1268                         MEM_freeN(buf);
1269                 }
1270         }
1271         else
1272                 BLI_strncpy(str, but->poin, maxlen);
1273
1274 }
1275
1276 void ui_set_but_string(uiBut *but, const char *str)
1277 {
1278         if(but->rnaprop) {
1279                 if(RNA_property_editable(&but->rnapoin, but->rnaprop))
1280                         RNA_property_string_set(&but->rnapoin, but->rnaprop, str);
1281         }
1282         else
1283                 BLI_strncpy(but->poin, str, but->max);
1284 }
1285
1286 /* ******************* Font ********************/
1287
1288 static void ui_set_ftf_font(float aspect)
1289 {
1290 #ifdef INTERNATIONAL
1291         if(aspect<1.15) {
1292                 FTF_SetFontSize('l');
1293         }
1294         else if(aspect<1.59) {
1295                 FTF_SetFontSize('m');
1296         }
1297         else {
1298                 FTF_SetFontSize('s');
1299         }
1300 #endif
1301 }
1302
1303 void uiSetCurFont(uiBlock *block, int index)
1304 {
1305         ui_set_ftf_font(block->aspect);
1306
1307         if(block->aspect<0.60) {
1308                 block->curfont= UIfont[index].xl;
1309         }
1310         else if(block->aspect<1.15) {
1311                 block->curfont= UIfont[index].large;
1312         }
1313         else if(block->aspect<1.59) {
1314                 block->curfont= UIfont[index].medium;
1315         }
1316         else {
1317                 block->curfont= UIfont[index].small;
1318         }
1319
1320         if(block->curfont==NULL) block->curfont= UIfont[index].large;
1321         if(block->curfont==NULL) block->curfont= UIfont[index].medium;
1322         if(block->curfont==NULL) printf("error block no font %s\n", block->name);
1323
1324 }
1325
1326 /* called by node editor */
1327 void *uiSetCurFont_ext(float aspect)
1328 {
1329         void *curfont;
1330
1331         ui_set_ftf_font(aspect);
1332
1333         if(aspect<0.60) {
1334                 curfont= UIfont[0].xl;
1335         }
1336         else if(aspect<1.15) {
1337                 curfont= UIfont[0].large;
1338         }
1339         else if(aspect<1.59) {
1340                 curfont= UIfont[0].medium;
1341         }
1342         else {
1343                 curfont= UIfont[0].small;
1344         }
1345
1346         if(curfont==NULL) curfont= UIfont[0].large;
1347         if(curfont==NULL) curfont= UIfont[0].medium;
1348
1349         return curfont;
1350 }
1351
1352 void uiDefFont(unsigned int index, void *xl, void *large, void *medium, void *small)
1353 {
1354         if(index>=UI_ARRAY) return;
1355
1356         UIfont[index].xl= xl;
1357         UIfont[index].large= large;
1358         UIfont[index].medium= medium;
1359         UIfont[index].small= small;
1360 }
1361
1362 /* ******************* Free ********************/
1363
1364 static void ui_free_link(uiLink *link)
1365 {
1366         if(link) {
1367                 BLI_freelistN(&link->lines);
1368                 MEM_freeN(link);
1369         }
1370 }
1371
1372 static void ui_free_but(const bContext *C, uiBut *but)
1373 {
1374         if(but->opptr) {
1375                 WM_operator_properties_free(but->opptr);
1376                 MEM_freeN(but->opptr);
1377         }
1378         if(but->active) ui_button_active_cancel(C, but);
1379         if(but->str && but->str != but->strdata) MEM_freeN(but->str);
1380         ui_free_link(but->link);
1381
1382         MEM_freeN(but);
1383 }
1384
1385 void uiFreeBlock(const bContext *C, uiBlock *block)
1386 {
1387         uiBut *but;
1388
1389         while( (but= block->buttons.first) ) {
1390                 BLI_remlink(&block->buttons, but);
1391                 ui_free_but(C, but);
1392         }
1393
1394         if(block->panel) {
1395                 block->panel->active= 0;
1396         }
1397         BLI_freelistN(&block->saferct);
1398
1399         MEM_freeN(block);
1400 }
1401
1402 void uiFreeBlocks(const bContext *C, ListBase *lb)
1403 {
1404         uiBlock *block;
1405
1406         while( (block= lb->first) ) {
1407                 BLI_remlink(lb, block);
1408                 uiFreeBlock(C, block);
1409         }
1410 }
1411
1412 void uiFreeInactiveBlocks(const bContext *C, ListBase *lb)
1413 {
1414         uiBlock *block, *nextblock;
1415
1416         for(block=lb->first; block; block=nextblock) {
1417                 nextblock= block->next;
1418
1419                 if(!block->handle) {
1420                         if(!block->active) {
1421                                 BLI_remlink(lb, block);
1422                                 uiFreeBlock(C, block);
1423                         }
1424                         else
1425                                 block->active= 0;
1426                 }
1427         }
1428 }
1429
1430 uiBlock *uiBeginBlock(const bContext *C, ARegion *region, char *name, short dt, short font)
1431 {
1432         ListBase *lb;
1433         uiBlock *block, *oldblock= NULL;
1434         wmWindow *window;
1435         int getsizex, getsizey;
1436
1437         window= CTX_wm_window(C);
1438         lb= &region->uiblocks;
1439
1440         /* each listbase only has one block with this name, free block
1441          * if is already there so it can be rebuilt from scratch */
1442         if(lb) {
1443                 for (oldblock= lb->first; oldblock; oldblock= oldblock->next)
1444                         if (BLI_streq(oldblock->name, name))
1445                                 break;
1446
1447                 if (oldblock) {
1448                         oldblock->active= 0;
1449                         oldblock->panel= NULL;
1450                 }
1451         }
1452
1453         block= MEM_callocN(sizeof(uiBlock), "uiBlock");
1454         block->oldblock= oldblock;
1455         block->active= 1;
1456
1457         /* at the beginning of the list! for dynamical menus/blocks */
1458         if(lb)
1459                 BLI_addhead(lb, block);
1460
1461         BLI_strncpy(block->name, name, sizeof(block->name));
1462
1463 #if 0
1464         /* draw win */
1465         block->win= win;
1466         /* window where queue event should be added, pretty weak this way!
1467            this is because the 'mainwin' pup menu's */
1468         block->winq= mywinget();
1469 #endif
1470
1471         block->dt= dt;
1472         block->themecol= TH_AUTO;
1473
1474         /* window matrix and aspect */
1475         if(region->swinid) {
1476                 wm_subwindow_getmatrix(window, region->swinid, block->winmat);
1477                 wm_subwindow_getsize(window, region->swinid, &getsizex, &getsizey);
1478
1479                 /* TODO - investigate why block->winmat[0][0] is negative
1480                  * in the image view when viewRedrawForce is called */
1481                 block->aspect= 2.0/fabs( (getsizex)*block->winmat[0][0]);
1482         }
1483         else {
1484                 /* no subwindow created yet, for menus for example, so we
1485                  * use the main window instead, since buttons are created
1486                  * there anyway */
1487                 wm_subwindow_getmatrix(window, window->winid, block->winmat);
1488                 wm_subwindow_getsize(window, window->winid, &getsizex, &getsizey);
1489
1490                 block->aspect= 2.0/fabs(getsizex*block->winmat[0][0]);
1491                 block->auto_open= 2;
1492         }
1493
1494         uiSetCurFont(block, font);
1495
1496         return block;
1497 }
1498
1499 uiBlock *uiGetBlock(char *name, ARegion *ar)
1500 {
1501         uiBlock *block= ar->uiblocks.first;
1502
1503         while(block) {
1504                 if( strcmp(name, block->name)==0 ) return block;
1505                 block= block->next;
1506         }
1507
1508         return NULL;
1509 }
1510
1511 void ui_check_but(uiBut *but)
1512 {
1513         /* if something changed in the button */
1514         ID *id;
1515         double value;
1516         float okwidth;
1517         int transopts= ui_translate_buttons();
1518         short pos;
1519
1520         ui_is_but_sel(but);
1521
1522         if(but->type==TEX || but->type==IDPOIN) transopts= 0;
1523
1524         /* test for min and max, icon sliders, etc */
1525         switch( but->type ) {
1526                 case NUM:
1527                 case SLI:
1528                 case SCROLL:
1529                 case NUMSLI:
1530                 case HSVSLI:
1531                         value= ui_get_but_val(but);
1532                         if(value < but->min) ui_set_but_val(but, but->min);
1533                         else if(value > but->max) ui_set_but_val(but, but->max);
1534                         break;
1535
1536                 case NUMABS:
1537                         value= fabs( ui_get_but_val(but) );
1538                         if(value < but->min) ui_set_but_val(but, but->min);
1539                         else if(value > but->max) ui_set_but_val(but, but->max);
1540                         break;
1541
1542                 case ICONTOG:
1543                 case ICONTOGN:
1544                         if(but->flag & UI_SELECT) but->iconadd= 1;
1545                         else but->iconadd= 0;
1546                         break;
1547
1548                 case ICONROW:
1549                         value= ui_get_but_val(but);
1550                         but->iconadd= (int)value- (int)(but->min);
1551                         break;
1552
1553                 case ICONTEXTROW:
1554                         value= ui_get_but_val(but);
1555                         but->iconadd= (int)value- (int)(but->min);
1556                         break;
1557         }
1558
1559
1560         /* safety is 4 to enable small number buttons (like 'users') */
1561         if(but->type==NUMSLI || but->type==HSVSLI)
1562                 okwidth= -4 + (but->x2 - but->x1)/2.0;
1563         else
1564                 okwidth= -4 + (but->x2 - but->x1);
1565
1566         /* name: */
1567         switch( but->type ) {
1568
1569         case MENU:
1570         case ICONTEXTROW:
1571
1572                 if(but->x2 - but->x1 > 24) {
1573                         value= ui_get_but_val(but);
1574                         ui_set_name_menu(but, (int)value);
1575                 }
1576                 break;
1577
1578         case NUM:
1579         case NUMSLI:
1580         case HSVSLI:
1581         case NUMABS:
1582
1583                 value= ui_get_but_val(but);
1584
1585                 if(ui_is_but_float(but)) {
1586                         if(value == FLT_MAX) sprintf(but->drawstr, "%sinf", but->str);
1587                         else if(value == -FLT_MAX) sprintf(but->drawstr, "%s-inf", but->str);
1588                         else if(but->a2) { /* amount of digits defined */
1589                                 if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value);
1590                                 else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value);
1591                                 else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value);
1592                                 else sprintf(but->drawstr, "%s%.4f", but->str, value);
1593                         }
1594                         else {
1595                                 if(but->max<10.001) sprintf(but->drawstr, "%s%.3f", but->str, value);
1596                                 else sprintf(but->drawstr, "%s%.2f", but->str, value);
1597                         }
1598                 }
1599                 else {
1600                         sprintf(but->drawstr, "%s%d", but->str, (int)value);
1601                 }
1602                 break;
1603
1604         case LABEL:
1605                 if(ui_is_but_float(but)) {
1606                         value= ui_get_but_val(but);
1607                         if(but->a2) { /* amount of digits defined */
1608                                 if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value);
1609                                 else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value);
1610                                 else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value);
1611                                 else sprintf(but->drawstr, "%s%.4f", but->str, value);
1612                         }
1613                         else {
1614                                 sprintf(but->drawstr, "%s%.2f", but->str, value);
1615                         }
1616                 }
1617                 else strcpy(but->drawstr, but->str);
1618
1619                 break;
1620
1621         case IDPOIN:
1622                 id= *(but->idpoin_idpp);
1623                 strcpy(but->drawstr, but->str);
1624                 if(id) strcat(but->drawstr, id->name+2);
1625                 break;
1626
1627         case TEX:
1628                 if(!but->editstr) {
1629                         char str[UI_MAX_DRAW_STR];
1630
1631                         ui_get_but_string(but, str, UI_MAX_DRAW_STR-strlen(but->str));
1632
1633                         strcpy(but->drawstr, but->str);
1634                         strcat(but->drawstr, str);
1635                 }
1636                 break;
1637
1638         case KEYEVT:
1639                 strcpy(but->drawstr, but->str);
1640                 if (but->flag & UI_SELECT) {
1641                         strcat(but->drawstr, "Press a key");
1642                 } else {
1643                         strcat(but->drawstr, WM_key_event_string((short) ui_get_but_val(but)));
1644                 }
1645                 break;
1646
1647         case BUT_TOGDUAL:
1648                 /* trying to get the dual-icon to left of text... not very nice */
1649                 if(but->str[0]) {
1650                         strcpy(but->drawstr, "  ");
1651                         strcpy(but->drawstr+2, but->str);
1652                 }
1653                 break;
1654         default:
1655                 strcpy(but->drawstr, but->str);
1656
1657         }
1658
1659         /* if we are doing text editing, this will override the drawstr */
1660         if(but->editstr) {
1661                 strcpy(but->drawstr, but->str);
1662                 strcat(but->drawstr, but->editstr);
1663         }
1664
1665         if(but->drawstr[0]) {
1666                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts);
1667                 // here should be check for less space for icon offsets...
1668                 if(but->type==MENU) okwidth -= 15;
1669         }
1670         else
1671                 but->strwidth= 0;
1672
1673                 /* automatic width */
1674         if(but->x2==0.0f && but->x1 > 0.0f) {
1675                 but->x2= (but->x1+but->strwidth+6);
1676         }
1677
1678         if(but->strwidth==0) but->drawstr[0]= 0;
1679         else if(but->type==BUTM || but->type==BLOCK);   // no clip string, uiTextBoundsBlock is used (hack!)
1680         else {
1681
1682                 /* calc but->ofs, to draw the string shorter if too long */
1683                 but->ofs= 0;
1684
1685                 while(but->strwidth > (int)okwidth ) {
1686
1687                         if ELEM3(but->type, NUM, NUMABS, TEX) { // only these cut off left
1688                                 but->ofs++;
1689                                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr+but->ofs, transopts);
1690
1691                                 /* textbut exception */
1692                                 if(but->editstr && but->pos != -1) {
1693                                         pos= but->pos+strlen(but->str);
1694                                         if(pos-1 < but->ofs) {
1695                                                 pos= but->ofs-pos+1;
1696                                                 but->ofs -= pos;
1697                                                 if(but->ofs<0) {
1698                                                         but->ofs= 0;
1699                                                         pos--;
1700                                                 }
1701                                                 but->drawstr[ strlen(but->drawstr)-pos ]= 0;
1702                                         }
1703                                 }
1704                         }
1705                         else {
1706                                 but->drawstr[ strlen(but->drawstr)-1 ]= 0;
1707                                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts);
1708                         }
1709
1710                         if(but->strwidth < 10) break;
1711                 }
1712         }
1713 }
1714
1715 static int ui_auto_themecol(uiBut *but)
1716 {
1717
1718         switch(but->type) {
1719         case BUT:
1720                 return TH_BUT_ACTION;
1721         case ROW:
1722         case TOG:
1723         case TOG3:
1724         case TOGR:
1725         case TOGN:
1726         case BUT_TOGDUAL:
1727                 return TH_BUT_SETTING;
1728         case SLI:
1729         case NUM:
1730         case NUMSLI:
1731         case NUMABS:
1732         case HSVSLI:
1733                 return TH_BUT_NUM;
1734         case TEX:
1735                 return TH_BUT_TEXTFIELD;
1736         case PULLDOWN:
1737         case BLOCK:
1738         case MENU:
1739         case BUTM:
1740                 // (weak!) detect if it is a blockloop
1741                 if(but->block->dt == UI_EMBOSSP) return TH_MENU_ITEM;
1742                 return TH_BUT_POPUP;
1743         case ROUNDBOX:
1744                 return TH_PANEL;
1745         default:
1746                 return TH_BUT_NEUTRAL;
1747         }
1748 }
1749
1750 void uiBlockBeginAlign(uiBlock *block)
1751 {
1752         /* if other align was active, end it */
1753         if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block);
1754
1755         block->flag |= UI_BUT_ALIGN_DOWN;
1756         /* buttons declared after this call will this align flag */
1757 }
1758
1759 static int buts_are_horiz(uiBut *but1, uiBut *but2)
1760 {
1761         float dx, dy;
1762
1763         dx= fabs( but1->x2 - but2->x1);
1764         dy= fabs( but1->y1 - but2->y2);
1765
1766         if(dx > dy) return 0;
1767         return 1;
1768 }
1769
1770 void uiBlockEndAlign(uiBlock *block)
1771 {
1772         uiBut *prev, *but=NULL, *next;
1773         int flag= 0, cols=0, rows=0;
1774         int theme= UI_GetThemeValue(TH_BUT_DRAWTYPE);
1775
1776         if ( !(ELEM4(theme, TH_MINIMAL, TH_SHADED, TH_ROUNDED, TH_ROUNDSHADED)) ) {
1777                 block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1778                 return;
1779         }
1780
1781         /* auto align:
1782                 - go back to first button of align start (ALIGN_DOWN)
1783                 - compare triples, and define flags
1784         */
1785         prev= block->buttons.last;
1786         while(prev) {
1787                 if( (prev->flag & UI_BUT_ALIGN_DOWN)) but= prev;
1788                 else break;
1789
1790                 if(but && but->next) {
1791                         if(buts_are_horiz(but, but->next)) cols++;
1792                         else rows++;
1793                 }
1794
1795                 prev= prev->prev;
1796         }
1797         if(but==NULL) return;
1798
1799         /* rows==0: 1 row, cols==0: 1 collumn */
1800
1801         /* note;  how it uses 'flag' in loop below (either set it, or OR it) is confusing */
1802         prev= NULL;
1803         while(but) {
1804                 next= but->next;
1805
1806                 /* clear old flag */
1807                 but->flag &= ~UI_BUT_ALIGN_DOWN;
1808
1809                 if(flag==0) {   /* first case */
1810                         if(next) {
1811                                 if(buts_are_horiz(but, next)) {
1812                                         if(rows==0)
1813                                                 flag= UI_BUT_ALIGN_RIGHT;
1814                                         else
1815                                                 flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT;
1816                                 }
1817                                 else {
1818                                         flag= UI_BUT_ALIGN_DOWN;
1819                                 }
1820                         }
1821                 }
1822                 else if(next==NULL) {   /* last case */
1823                         if(prev) {
1824                                 if(buts_are_horiz(prev, but)) {
1825                                         if(rows==0)
1826                                                 flag= UI_BUT_ALIGN_LEFT;
1827                                         else
1828                                                 flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT;
1829                                 }
1830                                 else flag= UI_BUT_ALIGN_TOP;
1831                         }
1832                 }
1833                 else if(buts_are_horiz(but, next)) {
1834                         /* check if this is already second row */
1835                         if( prev && buts_are_horiz(prev, but)==0) {
1836                                 flag |= UI_BUT_ALIGN_TOP;
1837                                 /* exception case: bottom row */
1838                                 if(rows>0) {
1839                                         uiBut *bt= but;
1840                                         while(bt) {
1841                                                 if(bt->next && buts_are_horiz(bt, bt->next)==0 ) break;
1842                                                 bt= bt->next;
1843                                         }
1844                                         if(bt==0) flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT;
1845                                 }
1846                         }
1847                         else flag |= UI_BUT_ALIGN_LEFT;
1848                 }
1849                 else {
1850                         if(cols==0) {
1851                                 flag |= UI_BUT_ALIGN_TOP;
1852                         }
1853                         else {  /* next button switches to new row */
1854                                 if( (flag & UI_BUT_ALIGN_TOP)==0) {     /* stil top row */
1855                                         if(prev)
1856                                                 flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT;
1857                                         else
1858                                                 flag |= UI_BUT_ALIGN_DOWN;
1859                                 }
1860                                 else
1861                                         flag |= UI_BUT_ALIGN_TOP;
1862                         }
1863                 }
1864
1865                 but->flag |= flag;
1866
1867                 /* merge coordinates */
1868                 if(prev) {
1869                         // simple cases
1870                         if(rows==0) {
1871                                 but->x1= (prev->x2+but->x1)/2.0;
1872                                 prev->x2= but->x1;
1873                         }
1874                         else if(cols==0) {
1875                                 but->y2= (prev->y1+but->y2)/2.0;
1876                                 prev->y1= but->y2;
1877                         }
1878                         else {
1879                                 if(buts_are_horiz(prev, but)) {
1880                                         but->x1= (prev->x2+but->x1)/2.0;
1881                                         prev->x2= but->x1;
1882                                         /* copy height too */
1883                                         but->y2= prev->y2;
1884                                 }
1885                                 else if(prev->prev && buts_are_horiz(prev->prev, prev)==0) {
1886                                         /* the previous button is a single one in its row */
1887                                         but->y2= (prev->y1+but->y2)/2.0;
1888                                         prev->y1= but->y2;
1889                                 }
1890                                 else {
1891                                         /* the previous button is not a single one in its row */
1892                                         but->y2= prev->y1;
1893                                 }
1894                         }
1895                 }
1896
1897                 prev= but;
1898                 but= next;
1899         }
1900
1901         block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1902 }
1903
1904 #if 0
1905 static void uiBlockEndAligno(uiBlock *block)
1906 {
1907         uiBut *but;
1908
1909         /* correct last defined button */
1910         but= block->buttons.last;
1911         if(but) {
1912                 /* vertical align case */
1913                 if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_DOWN) ) {
1914                         but->flag &= ~UI_BUT_ALIGN_DOWN;
1915                 }
1916                 /* horizontal align case */
1917                 if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_LEFT|UI_BUT_ALIGN_RIGHT) ) {
1918                         but->flag &= ~UI_BUT_ALIGN_RIGHT;
1919                 }
1920                 /* else do nothing, manually provided flags */
1921         }
1922         block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1923 }
1924 #endif
1925
1926 /*
1927 ui_def_but is the function that draws many button types
1928
1929 for float buttons:
1930         "a1" Click Step (how much to change the value each click)
1931         "a2" Number of decimal point values to display. 0 defaults to 3 (0.000) 1,2,3, and a maximum of 4,
1932        all greater values will be clamped to 4.
1933
1934 */
1935 static uiBut *ui_def_but(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
1936 {
1937         uiBut *but;
1938         short slen;
1939
1940         if(type & BUTPOIN) {            /* a pointer is required */
1941                 if(poin==NULL) {
1942                         /* if pointer is zero, button is removed and not drawn */
1943                         UI_ThemeColor(block->themecol);
1944                         glRects(x1,  y1,  x1+x2,  y1+y2);
1945                         return NULL;
1946                 }
1947         }
1948
1949         but= MEM_callocN(sizeof(uiBut), "uiBut");
1950
1951         but->type= type & BUTTYPE;
1952         but->pointype= type & BUTPOIN;
1953         but->bit= type & BIT;
1954         but->bitnr= type & 31;
1955         but->icon = 0;
1956
1957         BLI_addtail(&block->buttons, but);
1958
1959         but->retval= retval;
1960         if( strlen(str)>=UI_MAX_NAME_STR-1 ) {
1961                 but->str= MEM_callocN( strlen(str)+2, "uiDefBut");
1962                 strcpy(but->str, str);
1963         }
1964         else {
1965                 but->str= but->strdata;
1966                 strcpy(but->str, str);
1967         }
1968         but->x1= x1;
1969         but->y1= y1;
1970         if(block->autofill) {
1971                 but->x2= x2;
1972                 but->y2= y2;
1973         }
1974         else {
1975                 but->x2= (x1+x2);
1976                 but->y2= (y1+y2);
1977         }
1978         but->poin= poin;
1979         but->min= min;
1980         but->max= max;
1981         but->a1= a1;
1982         but->a2= a2;
1983         but->tip= tip;
1984
1985         but->font= block->curfont;
1986
1987         but->lock= block->lock;
1988         but->lockstr= block->lockstr;
1989
1990         but->aspect= block->aspect;
1991         but->win= block->win;
1992         but->block= block;              // pointer back, used for frontbuffer status, and picker
1993
1994         if(block->themecol==TH_AUTO) but->themecol= ui_auto_themecol(but);
1995         else but->themecol= block->themecol;
1996
1997         if(but->type != BUTM) {
1998                 but->func= block->func;
1999                 but->func_arg1= block->func_arg1;
2000                 but->func_arg2= block->func_arg2;
2001         }
2002
2003         ui_set_embossfunc(but, block->dt);
2004
2005         but->pos= -1;   /* cursor invisible */
2006
2007         if(ELEM(but->type, NUM, NUMABS)) {      /* add a space to name */
2008                 slen= strlen(but->str);
2009                 if(slen>0 && slen<UI_MAX_NAME_STR-2) {
2010                         if(but->str[slen-1]!=' ') {
2011                                 but->str[slen]= ' ';
2012                                 but->str[slen+1]= 0;
2013                         }
2014                 }
2015         }
2016
2017         if(but->type==HSVCUBE) { /* hsv buttons temp storage */
2018                 float rgb[3];
2019                 ui_get_but_vectorf(but, rgb);
2020                 rgb_to_hsv(rgb[0], rgb[1], rgb[2], but->hsv, but->hsv+1, but->hsv+2);
2021         }
2022
2023         if ELEM8(but->type, HSVSLI , NUMSLI, MENU, TEX, LABEL, IDPOIN, BLOCK, BUTM) {
2024                 but->flag |= UI_TEXT_LEFT;
2025         }
2026
2027         if(but->type==BUT_TOGDUAL) {
2028                 but->flag |= UI_ICON_LEFT;
2029         }
2030
2031         if(but->type==ROUNDBOX)
2032                 but->flag |= UI_NO_HILITE;
2033
2034         but->flag |= (block->flag & UI_BUT_ALIGN);
2035         if(block->flag & UI_BLOCK_NO_HILITE)
2036                 but->flag |= UI_NO_HILITE;
2037
2038         return but;
2039 }
2040
2041 uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2042 {
2043         uiBut *but;
2044         PropertyRNA *prop;
2045         PropertyType proptype;
2046         int freestr= 0;
2047
2048         prop= RNA_struct_find_property(ptr, propname);
2049         if(!prop)
2050                 return NULL;
2051
2052         proptype= RNA_property_type(ptr, prop);
2053
2054         /* use rna values if parameters are not specified */
2055         if(!str) {
2056                 if(type == MENU && proptype == PROP_ENUM) {
2057                         const EnumPropertyItem *item;
2058                         DynStr *dynstr;
2059                         int i, totitem;
2060
2061                         RNA_property_enum_items(ptr, prop, &item, &totitem);
2062
2063                         dynstr= BLI_dynstr_new();
2064                         BLI_dynstr_appendf(dynstr, "%s%%t", RNA_property_ui_name(ptr, prop));
2065                         for(i=0; i<totitem; i++)
2066                                 BLI_dynstr_appendf(dynstr, "|%s %%x%d", item[i].name, item[i].value);
2067                         str= BLI_dynstr_get_cstring(dynstr);
2068                         BLI_dynstr_free(dynstr);
2069
2070                         freestr= 1;
2071                 }
2072                 else
2073                         str= (char*)RNA_property_ui_name(ptr, prop);
2074         }
2075
2076         if(!tip)
2077                 tip= (char*)RNA_property_ui_description(ptr, prop);
2078
2079         if(min == max || a1 == -1 || a2 == -1) {
2080                 if(proptype == PROP_INT) {
2081                         int softmin, softmax, step;
2082
2083                         RNA_property_int_ui_range(ptr, prop, &softmin, &softmax, &step);
2084
2085                         if(min == max) {
2086                                 min= softmin;
2087                                 max= softmax;
2088                         }
2089                         if(a1 == -1)
2090                                 a1= step;
2091                         if(a2 == -1)
2092                                 a2= 0;
2093                 }
2094                 else if(proptype == PROP_FLOAT) {
2095                         float softmin, softmax, step, precision;
2096
2097                         RNA_property_float_ui_range(ptr, prop, &softmin, &softmax, &step, &precision);
2098
2099                         if(min == max) {
2100                                 min= softmin;
2101                                 max= softmax;
2102                         }
2103                         if(a1 == -1)
2104                                 a1= step;
2105                         if(a2 == -1)
2106                                 a2= precision;
2107                 }
2108                 else if(proptype == PROP_STRING) {
2109                         min= 0;
2110                         max= RNA_property_string_maxlength(ptr, prop);
2111                         if(max == 0) /* interface code should ideally support unlimited length */
2112                                 max= UI_MAX_DRAW_STR;
2113                 }
2114         }
2115
2116         /* now create button */
2117         but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, NULL, min, max, a1, a2, tip);
2118         but->rnapoin= *ptr;
2119         but->rnaprop= prop;
2120         but->rnaindex= index;
2121
2122         if(freestr)
2123                 MEM_freeN(str);
2124
2125         return but;
2126 }
2127
2128 uiBut *ui_def_but_operator(bContext *C, uiBlock *block, int type, char *opname, int opcontext, char *str, short x1, short y1, short x2, short y2, char *tip)
2129 {
2130         uiBut *but;
2131         char buf[100], *butstr;
2132
2133         if(!str) {
2134                 wmOperatorType *ot= WM_operatortype_find(opname);
2135                 str= (ot)? ot->name: "";
2136         }
2137
2138         butstr= str;
2139
2140         if(type == BUTM) {
2141                 if(WM_key_event_operator_string(C, opname, opcontext, buf, sizeof(buf))) {
2142                         butstr= MEM_mallocN(strlen(str)+strlen(buf)+2, "ui_def_but_operator");
2143                         strcpy(butstr, str);
2144                         strcat(butstr, "|");
2145                         strcat(butstr, buf);
2146                 }
2147         }
2148
2149         but= ui_def_but(block, type, -1, butstr, x1, y1, x2, y2, NULL, 0, 0, 0, 0, tip);
2150         but->opname= opname;
2151         but->opcontext= opcontext;
2152
2153         if(butstr != str)
2154                 MEM_freeN(butstr);
2155
2156         return but;
2157 }
2158
2159 uiBut *uiDefBut(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2160 {
2161         uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2162
2163         ui_check_but(but);
2164
2165         return but;
2166 }
2167
2168         /* if _x_ is a power of two (only one bit) return the power,
2169          * otherwise return -1.
2170          * (1<<findBitIndex(x))==x for powers of two.
2171          */
2172 static int findBitIndex(unsigned int x) {
2173         if (!x || (x&(x-1))!=0) {       /* x&(x-1) strips lowest bit */
2174                 return -1;
2175         } else {
2176                 int idx= 0;
2177
2178                 if (x&0xFFFF0000)       idx+=16, x>>=16;
2179                 if (x&0xFF00)           idx+=8, x>>=8;
2180                 if (x&0xF0)                     idx+=4, x>>=4;
2181                 if (x&0xC)                      idx+=2, x>>=2;
2182                 if (x&0x2)                      idx+=1;
2183
2184                 return idx;
2185         }
2186 }
2187
2188 /* autocomplete helper functions */
2189 struct AutoComplete {
2190         int maxlen;
2191         char *truncate;
2192         char *startname;
2193 };
2194
2195 AutoComplete *autocomplete_begin(char *startname, int maxlen)
2196 {
2197         AutoComplete *autocpl;
2198
2199         autocpl= MEM_callocN(sizeof(AutoComplete), "AutoComplete");
2200         autocpl->maxlen= maxlen;
2201         autocpl->truncate= MEM_callocN(sizeof(char)*maxlen, "AutoCompleteTruncate");
2202         autocpl->startname= startname;
2203
2204         return autocpl;
2205 }
2206
2207 void autocomplete_do_name(AutoComplete *autocpl, const char *name)
2208 {
2209         char *truncate= autocpl->truncate;
2210         char *startname= autocpl->startname;
2211         int a;
2212
2213         for(a=0; a<autocpl->maxlen-1; a++) {
2214                 if(startname[a]==0 || startname[a]!=name[a])
2215                         break;
2216         }
2217         /* found a match */
2218         if(startname[a]==0) {
2219                 /* first match */
2220                 if(truncate[0]==0)
2221                         BLI_strncpy(truncate, name, autocpl->maxlen);
2222                 else {
2223                         /* remove from truncate what is not in bone->name */
2224                         for(a=0; a<autocpl->maxlen-1; a++) {
2225                                 if(truncate[a]!=name[a])
2226                                         truncate[a]= 0;
2227                         }
2228                 }
2229         }
2230 }
2231
2232 void autocomplete_end(AutoComplete *autocpl, char *autoname)
2233 {
2234         if(autocpl->truncate[0])
2235                 BLI_strncpy(autoname, autocpl->truncate, autocpl->maxlen);
2236         else
2237                 BLI_strncpy(autoname, autocpl->startname, autocpl->maxlen);
2238
2239         MEM_freeN(autocpl->truncate);
2240         MEM_freeN(autocpl);
2241 }
2242
2243 /* autocomplete callback for ID buttons */
2244 static void autocomplete_id(bContext *C, char *str, void *arg_v)
2245 {
2246         int blocktype= (intptr_t)arg_v;
2247         ListBase *listb= wich_libbase(CTX_data_main(C), blocktype);
2248
2249         if(listb==NULL) return;
2250
2251         /* search if str matches the beginning of an ID struct */
2252         if(str[0]) {
2253                 AutoComplete *autocpl= autocomplete_begin(str, 22);
2254                 ID *id;
2255
2256                 for(id= listb->first; id; id= id->next)
2257                         autocomplete_do_name(autocpl, id->name+2);
2258
2259                 autocomplete_end(autocpl, str);
2260         }
2261 }
2262
2263 static uiBut *uiDefButBit(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2264 {
2265         int bitIdx= findBitIndex(bit);
2266         if (bitIdx==-1) {
2267                 return NULL;
2268         } else {
2269                 return uiDefBut(block, type|BIT|bitIdx, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2270         }
2271 }
2272 uiBut *uiDefButF(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2273 {
2274         return uiDefBut(block, type|FLO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2275 }
2276 uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2277 {
2278         return uiDefButBit(block, type|FLO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2279 }
2280 uiBut *uiDefButI(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2281 {
2282         return uiDefBut(block, type|INT, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2283 }
2284 uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2285 {
2286         return uiDefButBit(block, type|INT, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2287 }
2288 uiBut *uiDefButS(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2289 {
2290         return uiDefBut(block, type|SHO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2291 }
2292 uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2293 {
2294         return uiDefButBit(block, type|SHO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2295 }
2296 uiBut *uiDefButC(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2297 {
2298         return uiDefBut(block, type|CHA, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2299 }
2300 uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2301 {
2302         return uiDefButBit(block, type|CHA, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2303 }
2304 uiBut *uiDefButR(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2305 {
2306         uiBut *but;
2307
2308         but= ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2309         if(but)
2310                 ui_check_but(but);
2311
2312         return but;
2313 }
2314 uiBut *uiDefButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, char *str, short x1, short y1, short x2, short y2, char *tip)
2315 {
2316         uiBut *but;
2317
2318         but= ui_def_but_operator(C, block, type, opname, opcontext, str, x1, y1, x2, y2, tip);
2319         if(but)
2320                 ui_check_but(but);
2321
2322         return but;
2323 }
2324
2325 uiBut *uiDefIconBut(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2326 {
2327         uiBut *but= ui_def_but(block, type, retval, "", x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2328
2329         but->icon= (BIFIconID) icon;
2330         but->flag|= UI_HAS_ICON;
2331
2332         ui_check_but(but);
2333
2334         return but;
2335 }
2336 static uiBut *uiDefIconButBit(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2337 {
2338         int bitIdx= findBitIndex(bit);
2339         if (bitIdx==-1) {
2340                 return NULL;
2341         } else {
2342                 return uiDefIconBut(block, type|BIT|bitIdx, retval, icon, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2343         }
2344 }
2345
2346 uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2347 {
2348         return uiDefIconBut(block, type|FLO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2349 }
2350 uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2351 {
2352         return uiDefIconButBit(block, type|FLO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2353 }
2354 uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2355 {
2356         return uiDefIconBut(block, type|INT, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2357 }
2358 uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2359 {
2360         return uiDefIconButBit(block, type|INT, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2361 }
2362 uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2363 {
2364         return uiDefIconBut(block, type|SHO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2365 }
2366 uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2367 {
2368         return uiDefIconButBit(block, type|SHO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2369 }
2370 uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2371 {
2372         return uiDefIconBut(block, type|CHA, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2373 }
2374 uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2375 {
2376         return uiDefIconButBit(block, type|CHA, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2377 }
2378 uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2379 {
2380         uiBut *but;
2381
2382         but= ui_def_but_rna(block, type, retval, "", x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2383         if(but) {
2384                 but->icon= (BIFIconID) icon;
2385                 but->flag|= UI_HAS_ICON;
2386                 ui_check_but(but);
2387         }
2388
2389         return but;
2390 }
2391 uiBut *uiDefIconButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, int icon, short x1, short y1, short x2, short y2, char *tip)
2392 {
2393         uiBut *but;
2394
2395         but= ui_def_but_operator(C, block, type, opname, opcontext, "", x1, y1, x2, y2, tip);
2396         if(but) {
2397                 but->icon= (BIFIconID) icon;
2398                 but->flag|= UI_HAS_ICON;
2399                 ui_check_but(but);
2400         }
2401
2402         return but;
2403 }
2404
2405 /* Button containing both string label and icon */
2406 uiBut *uiDefIconTextBut(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2407 {
2408         uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2409
2410         but->icon= (BIFIconID) icon;
2411         but->flag|= UI_HAS_ICON;
2412
2413         but->flag|= UI_ICON_LEFT;
2414
2415         ui_check_but(but);
2416
2417         return but;
2418 }
2419 static uiBut *uiDefIconTextButBit(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2420 {
2421         int bitIdx= findBitIndex(bit);
2422         if (bitIdx==-1) {
2423                 return NULL;
2424         } else {
2425                 return uiDefIconTextBut(block, type|BIT|bitIdx, retval, icon, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2426         }
2427 }
2428
2429 uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2430 {
2431         return uiDefIconTextBut(block, type|FLO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2432 }
2433 uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2434 {
2435         return uiDefIconTextButBit(block, type|FLO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2436 }
2437 uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2438 {
2439         return uiDefIconTextBut(block, type|INT, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2440 }
2441 uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2442 {
2443         return uiDefIconTextButBit(block, type|INT, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2444 }
2445 uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2446 {
2447         return uiDefIconTextBut(block, type|SHO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2448 }
2449 uiBut *uiDefIconTextButBitS(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2450 {
2451         return uiDefIconTextButBit(block, type|SHO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2452 }
2453 uiBut *uiDefIconTextButC(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2454 {
2455         return uiDefIconTextBut(block, type|CHA, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2456 }
2457 uiBut *uiDefIconTextButBitC(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2458 {
2459         return uiDefIconTextButBit(block, type|CHA, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2460 }
2461 uiBut *uiDefIconTextButR(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2462 {
2463         uiBut *but;
2464
2465         but= ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2466         if(but) {
2467                 but->icon= (BIFIconID) icon;
2468                 but->flag|= UI_HAS_ICON;
2469                 but->flag|= UI_ICON_LEFT;
2470                 ui_check_but(but);
2471         }
2472
2473         return but;
2474 }
2475 uiBut *uiDefIconTextButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, int icon, char *str, short x1, short y1, short x2, short y2, char *tip)
2476 {
2477         uiBut *but;
2478
2479         but= ui_def_but_operator(C, block, type, opname, opcontext, str, x1, y1, x2, y2, tip);
2480         if(but) {
2481                 but->icon= (BIFIconID) icon;
2482                 but->flag|= UI_HAS_ICON;
2483                 but->flag|= UI_ICON_LEFT;
2484                 ui_check_but(but);
2485         }
2486
2487         return but;
2488 }
2489
2490 /* END Button containing both string label and icon */
2491
2492 void uiAutoBlock(uiBlock *block, float minx, float miny, float sizex, float sizey, int flag)
2493 {
2494         block->minx= minx;
2495         block->maxx= minx+sizex;
2496         block->miny= miny;
2497         block->maxy= miny+sizey;
2498
2499         block->autofill= flag;  /* also check for if it has to be done */
2500
2501 }
2502
2503 void uiSetButLink(uiBut *but, void **poin, void ***ppoin, short *tot, int from, int to)
2504 {
2505         uiLink *link;
2506
2507         link= but->link= MEM_callocN(sizeof(uiLink), "new uilink");
2508
2509         link->poin= poin;
2510         link->ppoin= ppoin;
2511         link->totlink= tot;
2512         link->fromcode= from;
2513         link->tocode= to;
2514 }
2515
2516 /* cruft to make uiBlock and uiBut private */
2517
2518 int uiBlocksGetYMin(ListBase *lb)
2519 {
2520         uiBlock *block;
2521         int min= 0;
2522
2523         for (block= lb->first; block; block= block->next)
2524                 if (block==lb->first || block->miny<min)
2525                         min= block->miny;
2526
2527         return min;
2528 }
2529
2530 int uiBlockGetCol(uiBlock *block)
2531 {
2532         return block->themecol;
2533 }
2534 void uiBlockSetCol(uiBlock *block, int col)
2535 {
2536         block->themecol= col;
2537 }
2538 void uiBlockSetEmboss(uiBlock *block, int emboss)
2539 {
2540         block->dt= emboss;
2541 }
2542 void uiBlockSetDirection(uiBlock *block, int direction)
2543 {
2544         block->direction= direction;
2545 }
2546
2547 /* this call escapes if there's alignment flags */
2548 void uiBlockFlipOrder(uiBlock *block)
2549 {
2550         ListBase lb;
2551         uiBut *but, *next;
2552         float centy, miny=10000, maxy= -10000;
2553
2554 //      if(U.uiflag & USER_PLAINMENUS)
2555 //              return;
2556
2557         for(but= block->buttons.first; but; but= but->next) {
2558                 if(but->flag & UI_BUT_ALIGN) return;
2559                 if(but->y1 < miny) miny= but->y1;
2560                 if(but->y2 > maxy) maxy= but->y2;
2561         }
2562         /* mirror trick */
2563         centy= (miny+maxy)/2.0;
2564         for(but= block->buttons.first; but; but= but->next) {
2565                 but->y1 = centy-(but->y1-centy);
2566                 but->y2 = centy-(but->y2-centy);
2567                 SWAP(float, but->y1, but->y2);
2568         }
2569
2570         /* also flip order in block itself, for example for arrowkey */
2571         lb.first= lb.last= NULL;
2572         but= block->buttons.first;
2573         while(but) {
2574                 next= but->next;
2575                 BLI_remlink(&block->buttons, but);
2576                 BLI_addtail(&lb, but);
2577                 but= next;
2578         }
2579         block->buttons= lb;
2580 }
2581
2582
2583 void uiBlockSetFlag(uiBlock *block, int flag)
2584 {
2585         block->flag= flag;
2586 }
2587 void uiBlockSetXOfs(uiBlock *block, int xofs)
2588 {
2589         block->xofs= xofs;
2590 }
2591 void* uiBlockGetCurFont(uiBlock *block)
2592 {
2593         return block->curfont;
2594 }
2595
2596 void uiButSetFlag(uiBut *but, int flag)
2597 {
2598         but->flag|= flag;
2599 }
2600 void uiButClearFlag(uiBut *but, int flag)
2601 {
2602         but->flag&= ~flag;
2603 }
2604
2605 int uiButGetRetVal(uiBut *but)
2606 {
2607         return but->retval;
2608 }
2609
2610 PointerRNA *uiButGetOperatorPtrRNA(uiBut *but)
2611 {
2612         if(but->opname && !but->opptr) {
2613                 but->opptr= MEM_callocN(sizeof(PointerRNA), "uiButOpPtr");
2614                 WM_operator_properties_create(but->opptr, but->opname);
2615         }
2616
2617         return but->opptr;
2618 }
2619
2620 void uiBlockSetHandleFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int event), void *arg)
2621 {
2622         block->handle_func= func;
2623         block->handle_func_arg= arg;
2624 }
2625
2626 void uiBlockSetButmFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int but_a2), void *arg)
2627 {
2628         block->butm_func= func;
2629         block->butm_func_arg= arg;
2630 }
2631
2632 void uiBlockSetFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2)
2633 {
2634         block->func= func;
2635         block->func_arg1= arg1;
2636         block->func_arg2= arg2;
2637 }
2638
2639 void uiBlockSetDrawExtraFunc(uiBlock *block, void (*func)())
2640 {
2641         block->drawextra= func;
2642 }
2643
2644 void uiButSetFunc(uiBut *but, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2)
2645 {
2646         but->func= func;
2647         but->func_arg1= arg1;
2648         but->func_arg2= arg2;
2649 }
2650
2651 void uiButSetCompleteFunc(uiBut *but, void (*func)(struct bContext *C, char *str, void *arg), void *arg)
2652 {
2653         but->autocomplete_func= func;
2654         but->autofunc_arg= arg;
2655 }
2656
2657 uiBut *uiDefIDPoinBut(uiBlock *block, uiIDPoinFuncFP func, short blocktype, int retval, char *str, short x1, short y1, short x2, short y2, void *idpp, char *tip)
2658 {
2659         uiBut *but= ui_def_but(block, IDPOIN, retval, str, x1, y1, x2, y2, NULL, 0.0, 0.0, 0.0, 0.0, tip);
2660         but->idpoin_func= func;
2661         but->idpoin_idpp= (ID**) idpp;
2662         ui_check_but(but);
2663
2664         if(blocktype)
2665                 uiButSetCompleteFunc(but, autocomplete_id, (void *)(intptr_t)blocktype);
2666
2667         return but;
2668 }
2669
2670 uiBut *uiDefBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip)
2671 {
2672         uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2673         but->block_func= func;
2674         ui_check_but(but);
2675         return but;
2676 }
2677
2678 uiBut *uiDefPulldownBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip)
2679 {
2680         uiBut *but= ui_def_but(block, PULLDOWN, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2681         but->block_func= func;
2682         ui_check_but(but);
2683         return but;
2684 }
2685
2686 /* Block button containing both string label and icon */
2687 uiBut *uiDefIconTextBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int icon, char *str, short x1, short y1, short x2, short y2, char *tip)
2688 {
2689         uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2690
2691         but->icon= (BIFIconID) icon;
2692         but->flag|= UI_HAS_ICON;
2693
2694         but->flag|= UI_ICON_LEFT;
2695         but->flag|= UI_ICON_RIGHT;
2696
2697         but->block_func= func;
2698         ui_check_but(but);
2699
2700         return but;
2701 }
2702
2703 /* Block button containing icon */
2704 uiBut *uiDefIconBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int retval, int icon, short x1, short y1, short x2, short y2, char *tip)
2705 {
2706         uiBut *but= ui_def_but(block, BLOCK, retval, "", x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2707
2708         but->icon= (BIFIconID) icon;
2709         but->flag|= UI_HAS_ICON;
2710
2711         but->flag|= UI_ICON_LEFT;
2712         but->flag|= UI_ICON_RIGHT;
2713
2714         but->block_func= func;
2715         ui_check_but(but);
2716
2717         return but;
2718 }
2719
2720 void uiDefKeyevtButS(uiBlock *block, int retval, char *str, short x1, short y1, short x2, short y2, short *spoin, char *tip)
2721 {
2722         uiBut *but= ui_def_but(block, KEYEVT|SHO, retval, str, x1, y1, x2, y2, spoin, 0.0, 0.0, 0.0, 0.0, tip);
2723         ui_check_but(but);
2724 }
2725
2726 /* Program Init/Exit */
2727
2728 void UI_init(void)
2729 {
2730         uiDefFont(UI_HELVB,
2731                                 BMF_GetFont(BMF_kHelveticaBold14),
2732                                 BMF_GetFont(BMF_kHelveticaBold12),
2733                                 BMF_GetFont(BMF_kHelveticaBold10),
2734                                 BMF_GetFont(BMF_kHelveticaBold8));
2735         uiDefFont(UI_HELV,
2736                                 BMF_GetFont(BMF_kHelvetica12),
2737                                 BMF_GetFont(BMF_kHelvetica12),
2738                                 BMF_GetFont(BMF_kHelvetica10),
2739                                 BMF_GetFont(BMF_kHelveticaBold8));
2740
2741         ui_resources_init();
2742 }
2743
2744 void UI_init_userdef()
2745 {
2746         ui_text_init_userdef();
2747         ui_theme_init_userdef();
2748 }
2749
2750 void UI_exit(void)
2751 {
2752         ui_resources_free();
2753 }
2754