diff options
Diffstat (limited to 'source/blender/editors/interface/interface.c')
| -rw-r--r-- | source/blender/editors/interface/interface.c | 2601 |
1 files changed, 2601 insertions, 0 deletions
diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c new file mode 100644 index 00000000000..2562a5e6bb3 --- /dev/null +++ b/source/blender/editors/interface/interface.c @@ -0,0 +1,2601 @@ +/** + * $Id: interface.c 16882 2008-10-02 12:29:45Z ton $ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <float.h> +#include <math.h> +#include <string.h> + +#include "MEM_guardedalloc.h" + +#include "DNA_ID.h" +#include "DNA_listBase.h" +#include "DNA_screen_types.h" +#include "DNA_texture_types.h" +#include "DNA_userdef_types.h" + +#include "BLI_arithb.h" +#include "BLI_blenlib.h" +#include "BLI_dynstr.h" + +#include "BKE_global.h" +#include "BKE_screen.h" +#include "BKE_texture.h" +#include "BKE_utildefines.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "UI_interface.h" +#include "UI_text.h" + +#include "BMF_Api.h" +#ifdef INTERNATIONAL +#include "FTF_Api.h" +#endif + +#include "ED_screen.h" + +#include "WM_api.h" +#include "WM_types.h" +#include "wm_subwindow.h" +#include "wm_window.h" + +#include "RNA_access.h" +#include "RNA_types.h" + +#include "interface.h" + +/* + * a full doc with API notes can be found in bf-blender/blender/doc/interface_API.txt + * + * uiBlahBlah() external function + * ui_blah_blah() internal function + */ + +static void ui_free_but(const bContext *C, uiBut *but); + +/* ************ GLOBALS ************* */ + +static uiFont UIfont[UI_ARRAY]; // no init needed + +/* ************* translation ************** */ + +/* XXX 2.50 missing from context */ +int ui_translate_buttons() +{ + return (U.transopts & USER_TR_BUTTONS); +} + +int ui_translate_menus() +{ + return (U.transopts & USER_TR_MENUS); +} + +int ui_translate_tooltips() +{ + return (U.transopts & USER_TR_TOOLTIPS); +} + +/* ************* window matrix ************** */ + +void ui_block_to_window_fl(const ARegion *ar, uiBlock *block, float *x, float *y) +{ + float gx, gy; + int sx, sy, getsizex, getsizey; + + getsizex= ar->winrct.xmax-ar->winrct.xmin+1; + getsizey= ar->winrct.ymax-ar->winrct.ymin+1; + sx= ar->winrct.xmin; + sy= ar->winrct.ymin; + + gx= *x; + gy= *y; + *x= ((float)sx) + ((float)getsizex)*(0.5+ 0.5*(gx*block->winmat[0][0]+ gy*block->winmat[1][0]+ block->winmat[3][0])); + *y= ((float)sy) + ((float)getsizey)*(0.5+ 0.5*(gx*block->winmat[0][1]+ gy*block->winmat[1][1]+ block->winmat[3][1])); +} + +void ui_block_to_window(const ARegion *ar, uiBlock *block, int *x, int *y) +{ + float fx, fy; + + fx= *x; + fy= *y; + + ui_block_to_window_fl(ar, block, &fx, &fy); + + *x= (int)(fx+0.5f); + *y= (int)(fy+0.5f); +} + +void ui_block_to_window_rct(const ARegion *ar, uiBlock *block, rctf *graph, rcti *winr) +{ + rctf tmpr; + + tmpr= *graph; + ui_block_to_window_fl(ar, block, &tmpr.xmin, &tmpr.ymin); + ui_block_to_window_fl(ar, block, &tmpr.xmax, &tmpr.ymax); + + winr->xmin= tmpr.xmin; + winr->ymin= tmpr.ymin; + winr->xmax= tmpr.xmax; + winr->ymax= tmpr.ymax; +} + +void ui_window_to_block_fl(const ARegion *ar, uiBlock *block, float *x, float *y) /* for mouse cursor */ +{ + float a, b, c, d, e, f, px, py; + int sx, sy, getsizex, getsizey; + + getsizex= ar->winrct.xmax-ar->winrct.xmin+1; + getsizey= ar->winrct.ymax-ar->winrct.ymin+1; + sx= ar->winrct.xmin; + sy= ar->winrct.ymin; + + a= .5*((float)getsizex)*block->winmat[0][0]; + b= .5*((float)getsizex)*block->winmat[1][0]; + c= .5*((float)getsizex)*(1.0+block->winmat[3][0]); + + d= .5*((float)getsizey)*block->winmat[0][1]; + e= .5*((float)getsizey)*block->winmat[1][1]; + f= .5*((float)getsizey)*(1.0+block->winmat[3][1]); + + px= *x - sx; + py= *y - sy; + + *y= (a*(py-f) + d*(c-px))/(a*e-d*b); + *x= (px- b*(*y)- c)/a; +} + +void ui_window_to_block(const ARegion *ar, uiBlock *block, int *x, int *y) +{ + float fx, fy; + + fx= *x; + fy= *y; + + ui_window_to_block_fl(ar, block, &fx, &fy); + + *x= (int)(fx+0.5f); + *y= (int)(fy+0.5f); +} + +void ui_window_to_region(const ARegion *ar, int *x, int *y) +{ + *x-= ar->winrct.xmin; + *y-= ar->winrct.ymin; +} + +/* ******************* block calc ************************* */ + +/* only for pulldowns */ +void uiTextBoundsBlock(uiBlock *block, int addval) +{ + uiBut *bt; + int i = 0, j, x1addval= 0, nextcol; + + bt= block->buttons.first; + while(bt) { + if(bt->type!=SEPR) { + int transopts= ui_translate_buttons(); + if(bt->type==TEX || bt->type==IDPOIN) transopts= 0; + j= UI_GetStringWidth(bt->font, bt->drawstr, transopts); + + if(j > i) i = j; + } + bt= bt->next; + } + + /* cope with multi collumns */ + bt= block->buttons.first; + while(bt) { + if(bt->next && bt->x1 < bt->next->x1) + nextcol= 1; + else nextcol= 0; + + bt->x1 = x1addval; + bt->x2 = bt->x1 + i + addval; + + ui_check_but(bt); // clips text again + + if(nextcol) + x1addval+= i + addval; + + bt= bt->next; + } +} + +void uiBoundsBlock(uiBlock *block, int addval) +{ + uiBut *bt; + int xof; + + if(block==NULL) + return; + + if(block->buttons.first==NULL) { + if(block->panel) { + block->minx= 0.0; block->maxx= block->panel->sizex; + block->miny= 0.0; block->maxy= block->panel->sizey; + } + } + else { + + block->minx= block->miny= 10000; + block->maxx= block->maxy= -10000; + + bt= block->buttons.first; + while(bt) { + if(bt->x1 < block->minx) block->minx= bt->x1; + if(bt->y1 < block->miny) block->miny= bt->y1; + + if(bt->x2 > block->maxx) block->maxx= bt->x2; + if(bt->y2 > block->maxy) block->maxy= bt->y2; + + bt= bt->next; + } + + block->minx -= addval; + block->miny -= addval; + block->maxx += addval; + block->maxy += addval; + } + + /* hardcoded exception... but that one is annoying with larger safety */ + bt= block->buttons.first; + if(bt && strncmp(bt->str, "ERROR", 5)==0) xof= 10; + else xof= 40; + + block->safety.xmin= block->minx-xof; + block->safety.ymin= block->miny-xof; + block->safety.xmax= block->maxx+xof; + block->safety.ymax= block->maxy+xof; +} + +void uiBlockTranslate(uiBlock *block, int x, int y) +{ + uiBut *bt; + + for(bt= block->buttons.first; bt; bt=bt->next) { + bt->x1 += x; + bt->y1 += y; + bt->x2 += x; + bt->y2 += y; + } + + block->minx += x; + block->miny += y; + block->maxx += x; + block->maxy += y; +} + +void uiBlockOrigin(uiBlock *block) +{ + uiBut *bt; + int minx= 10000, miny= 10000; + + for(bt= block->buttons.first; bt; bt=bt->next) { + if(bt->x1 < minx) minx= bt->x1; + if(bt->y1 < miny) miny= bt->y1; + } + + uiBlockTranslate(block, -minx, -miny); +} + +void ui_autofill(uiBlock *block) +{ + uiBut *but; + float *maxw, *maxh, startx = 0, starty, height = 0; + float totmaxh; + int rows=0, /* cols=0, */ i, lasti; + + /* first count rows */ + but= block->buttons.last; + rows= but->x1+1; + + /* calculate max width / height for each row */ + maxw= MEM_callocN(sizeof(float)*rows, "maxw"); + maxh= MEM_callocN(sizeof(float)*rows, "maxh"); + but= block->buttons.first; + while(but) { + i= but->x1; + if( maxh[i] < but->y2) maxh[i]= but->y2; + maxw[i] += but->x2; + but= but->next; + } + + totmaxh= 0.0; + for(i=0; i<rows; i++) totmaxh+= maxh[i]; + + /* apply widths/heights */ + starty= block->maxy; + but= block->buttons.first; + lasti= -1; + while(but) { + // signal for aligning code + but->flag |= UI_BUT_ALIGN_DOWN; + + i= but->x1; + + if(i!=lasti) { + startx= block->minx; + height= (maxh[i]*(block->maxy-block->miny))/totmaxh; + starty-= height; + lasti= i; + } + + but->y1= starty+but->aspect; + but->y2= but->y1+height-but->aspect; + + but->x2= (but->x2*(block->maxx-block->minx))/maxw[i]; + but->x1= startx+but->aspect; + + startx+= but->x2; + but->x2+= but->x1-but->aspect; + + ui_check_but(but); + + but= but->next; + } + + uiBlockEndAlign(block); + + MEM_freeN(maxw); MEM_freeN(maxh); + block->autofill= 0; +} + +/* ************** LINK LINE DRAWING ************* */ + +/* link line drawing is not part of buttons or theme.. so we stick with it here */ + +static void ui_draw_linkline(uiBut *but, uiLinkLine *line) +{ + float vec1[2], vec2[2]; + + if(line->from==NULL || line->to==NULL) return; + + vec1[0]= (line->from->x1+line->from->x2)/2.0; + vec1[1]= (line->from->y1+line->from->y2)/2.0; + vec2[0]= (line->to->x1+line->to->x2)/2.0; + vec2[1]= (line->to->y1+line->to->y2)/2.0; + + if(line->flag & UI_SELECT) UI_ThemeColorShade(but->themecol, 80); + else glColor3ub(0,0,0); + fdrawline(vec1[0], vec1[1], vec2[0], vec2[1]); +} + +static void ui_draw_links(uiBlock *block) +{ + uiBut *but; + uiLinkLine *line; + + but= block->buttons.first; + while(but) { + if(but->type==LINK && but->link) { + line= but->link->lines.first; + while(line) { + ui_draw_linkline(but, line); + line= line->next; + } + } + but= but->next; + } +} + +/* ************** BLOCK ENDING FUNCTION ************* */ + +static int ui_but_equals_old(uiBut *but, uiBut *oldbut) +{ + /* various properties are being compared here, hopfully sufficient + * to catch all cases, but it is simple to add more checks later */ + if(but->retval != oldbut->retval) return 0; + if(but->poin != oldbut->poin || but->pointype != oldbut->pointype) return 0; + if(but->rnapoin.data != oldbut->rnapoin.data) return 0; + if(but->rnaprop != oldbut->rnaprop) + if(but->rnaindex != oldbut->rnaindex) return 0; + if(but->func != oldbut->func) return 0; + if(but->func_arg1 != oldbut->func_arg1) return 0; + if(but->func_arg2 != oldbut->func_arg2) return 0; + + return 1; +} + +static int ui_but_update_from_old_block(const bContext *C, uiBlock *block, uiBut *but) +{ + uiBlock *oldblock; + uiBut *oldbut; + int found= 0; + + oldblock= block->oldblock; + if(!oldblock) + return found; + + for(oldbut=oldblock->buttons.first; oldbut; oldbut=oldbut->next) { + if(ui_but_equals_old(oldbut, but)) { + if(oldbut->active) { + but->flag= oldbut->flag; + but->active= oldbut->active; + but->pos= oldbut->pos; + but->editstr= oldbut->editstr; + but->editval= oldbut->editval; + but->editvec= oldbut->editvec; + but->editcoba= oldbut->editcoba; + but->editcumap= oldbut->editcumap; + but->selsta= oldbut->selsta; + but->selend= oldbut->selend; + found= 1; + + oldbut->active= NULL; + } + + /* ensures one button can get activated, and in case the buttons + * draw are the same this gives O(1) lookup for each button */ + BLI_remlink(&oldblock->buttons, oldbut); + ui_free_but(C, oldbut); + + break; + } + } + + return found; +} + +void uiEndBlock(const bContext *C, uiBlock *block) +{ + uiBut *but; + + /* inherit flags from 'old' buttons that was drawn here previous, based + * on matching buttons, we need this to make button event handling non + * blocking, while still alowing buttons to be remade each redraw as it + * is expected by blender code */ + for(but=block->buttons.first; but; but=but->next) + if(ui_but_update_from_old_block(C, block, but)) + ui_check_but(but); + + if(block->oldblock) { + block->auto_open= block->oldblock->auto_open; + block->auto_open_last= block->oldblock->auto_open_last; + block->tooltipdisabled= block->oldblock->tooltipdisabled; + + uiFreeBlock(C, block->oldblock); + block->oldblock= NULL; + } + + /* handle pending stuff */ + if(block->autofill) ui_autofill(block); + if(block->minx==0.0 && block->maxx==0.0) uiBoundsBlock(block, 0); + if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block); +} + +/* ************** BLOCK DRAWING FUNCTION ************* */ + +void uiDrawBlock(uiBlock *block) +{ + uiBut *but; + + /* we set this only once */ + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + /* XXX 2.50 no panels yet */ + //uiPanelPush(block); // panel matrix + + if(block->flag & UI_BLOCK_LOOP) { + uiDrawMenuBox(block->minx, block->miny, block->maxx, block->maxy, block->flag); + } + else { + /* XXX 2.50 no panels yet */ + //if(block->panel) ui_draw_panel(block); + } + + /* XXX 2.50 need context here? */ + //if(block->drawextra) block->drawextra(curarea, block); + + for (but= block->buttons.first; but; but= but->next) + ui_draw_but(but); + + ui_draw_links(block); + + /* XXX 2.50 no panels yet */ + //uiPanelPop(block); // matrix restored +} + +/* ************* EVENTS ************* */ + +static void ui_is_but_sel(uiBut *but) +{ + double value; + int lvalue; + short push=0, true=1; + + value= ui_get_but_val(but); + + if( but->type==TOGN || but->type==ICONTOGN) true= 0; + + if( but->bit ) { + lvalue= (int)value; + if( BTST(lvalue, (but->bitnr)) ) push= true; + else push= !true; + } + else { + switch(but->type) { + case BUT: + push= 2; + break; + case KEYEVT: + if (value==-1) push= 1; + break; + case TOG: + case TOGR: + case TOG3: + case BUT_TOGDUAL: + case ICONTOG: + if(value!=but->min) push= 1; + break; + case ICONTOGN: + case TOGN: + if(value==0.0) push= 1; + break; + case ROW: + if(value == but->max) push= 1; + break; + case COL: + push= 1; + break; + default: + push= 2; + break; + } + } + + if(push==2); + else if(push==1) but->flag |= UI_SELECT; + else but->flag &= ~UI_SELECT; +} + +/* XXX 2.50 no links supported yet */ + +#if 0 +static uiBut *ui_get_valid_link_button(uiBlock *block, uiBut *but, short *mval) +{ + uiBut *bt; + + /* find button to link to */ + for (bt= block->buttons.first; bt; bt= bt->next) + if(bt!=but && uibut_contains_pt(bt, mval)) + break; + + if (bt) { + if (but->type==LINK && bt->type==INLINK) { + if( but->link->tocode == (int)bt->min ) { + return bt; + } + } + else if(but->type==INLINK && bt->type==LINK) { + if( bt->link->tocode == (int)but->min ) { + return bt; + } + } + } + + return NULL; +} + +static int ui_is_a_link(uiBut *from, uiBut *to) +{ + uiLinkLine *line; + uiLink *link; + + link= from->link; + if(link) { + line= link->lines.first; + while(line) { + if(line->from==from && line->to==to) return 1; + line= line->next; + } + } + return 0; +} + +static uiBut *ui_find_inlink(uiBlock *block, void *poin) +{ + uiBut *but; + + but= block->buttons.first; + while(but) { + if(but->type==INLINK) { + if(but->poin == poin) return but; + } + but= but->next; + } + return NULL; +} + +static void ui_add_link_line(ListBase *listb, uiBut *but, uiBut *bt) +{ + uiLinkLine *line; + + line= MEM_callocN(sizeof(uiLinkLine), "linkline"); + BLI_addtail(listb, line); + line->from= but; + line->to= bt; +} + +uiBut *uiFindInlink(uiBlock *block, void *poin) +{ + return ui_find_inlink(block, poin); +} + +void uiComposeLinks(uiBlock *block) +{ + uiBut *but, *bt; + uiLink *link; + void ***ppoin; + int a; + + but= block->buttons.first; + while(but) { + if(but->type==LINK) { + link= but->link; + + /* for all pointers in the array */ + if(link) { + if(link->ppoin) { + ppoin= link->ppoin; + for(a=0; a < *(link->totlink); a++) { + bt= ui_find_inlink(block, (*ppoin)[a] ); + if(bt) { + ui_add_link_line(&link->lines, but, bt); + } + } + } + else if(link->poin) { + bt= ui_find_inlink(block, *(link->poin) ); + if(bt) { + ui_add_link_line(&link->lines, but, bt); + } + } + } + } + but= but->next; + } +} + +static void ui_add_link(uiBut *from, uiBut *to) +{ + /* in 'from' we have to add a link to 'to' */ + uiLink *link; + void **oldppoin; + int a; + + if(ui_is_a_link(from, to)) { + printf("already exists\n"); + return; + } + + link= from->link; + + /* are there more pointers allowed? */ + if(link->ppoin) { + oldppoin= *(link->ppoin); + + (*(link->totlink))++; + *(link->ppoin)= MEM_callocN( *(link->totlink)*sizeof(void *), "new link"); + + for(a=0; a< (*(link->totlink))-1; a++) { + (*(link->ppoin))[a]= oldppoin[a]; + } + (*(link->ppoin))[a]= to->poin; + + if(oldppoin) MEM_freeN(oldppoin); + } + else { + *(link->poin)= to->poin; + } + +} + +static int ui_do_but_LINK(uiBlock *block, uiBut *but) +{ + /* + * This button only visualizes, the dobutton mode + * can add a new link, but then the whole system + * should be redrawn/initialized. + * + */ + uiBut *bt=0, *bto=NULL; + short sval[2], mval[2], mvalo[2], first= 1; + + uiGetMouse(curarea->win, sval); + mvalo[0]= sval[0]; + mvalo[1]= sval[1]; + + while (get_mbut() & L_MOUSE) { + uiGetMouse(curarea->win, mval); + + if(mval[0]!=mvalo[0] || mval[1]!=mvalo[1] || first) { + /* clear completely, because of drawbuttons */ + bt= ui_get_valid_link_button(block, but, mval); + if(bt) { + bt->flag |= UI_ACTIVE; + ui_draw_but(bt); + } + if(bto && bto!=bt) { + bto->flag &= ~UI_ACTIVE; + ui_draw_but(bto); + } + bto= bt; + + if (!first) { + glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]); + } + glutil_draw_front_xor_line(sval[0], sval[1], mval[0], mval[1]); + + mvalo[0]= mval[0]; + mvalo[1]= mval[1]; + + first= 0; + } + else UI_wait_for_statechange(); + } + + if (!first) { + glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]); + } + + if(bt) { + if(but->type==LINK) ui_add_link(but, bt); + else ui_add_link(bt, but); + + scrarea_queue_winredraw(curarea); + } + + return 0; +} +#endif + +/* ************************************************ */ + +void uiBlockSetButLock(uiBlock *block, int val, char *lockstr) +{ + block->lock |= val; + if(val) block->lockstr= lockstr; +} + +void uiBlockClearButLock(uiBlock *block) +{ + block->lock= 0; + block->lockstr= NULL; +} + +/* *************************************************************** */ + +/* XXX 2.50 no button editing */ + +#if 0 +static void setup_file(uiBlock *block) +{ + uiBut *but; + FILE *fp; + + fp= fopen("butsetup","w"); + if(fp==NULL); + else { + but= block->buttons.first; + while(but) { + ui_check_but(but); + 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); + but= but->next; + } + fclose(fp); + } +} + + +static void edit_but(uiBlock *block, uiBut *but, uiEvent *uevent) +{ + short dx, dy, mval[2], mvalo[2], didit=0; + + getmouseco_sc(mvalo); + while(TRUE) { + if( !(get_mbut() & L_MOUSE) ) break; + + getmouseco_sc(mval); + dx= (mval[0]-mvalo[0]); + dy= (mval[1]-mvalo[1]); + + if(dx!=0 || dy!=0) { + mvalo[0]= mval[0]; + mvalo[1]= mval[1]; + + cpack(0xc0c0c0); + glRectf(but->x1-2, but->y1-2, but->x2+2, but->y2+2); + + if((uevent->qual & LR_SHIFTKEY)==0) { + but->x1 += dx; + but->y1 += dy; + } + but->x2 += dx; + but->y2 += dy; + + ui_draw_but(but); + ui_block_flush_back(but->block); + didit= 1; + + } + /* idle for this poor code */ + else PIL_sleep_ms(30); + } + if(didit) setup_file(block); +} +#endif + +/* XXX 2.50 no links supported yet */ +#if 0 +static void ui_delete_active_linkline(uiBlock *block) +{ + uiBut *but; + uiLink *link; + uiLinkLine *line, *nline; + int a, b; + + but= block->buttons.first; + while(but) { + if(but->type==LINK && but->link) { + line= but->link->lines.first; + while(line) { + + nline= line->next; + + if(line->flag & UI_SELECT) { + BLI_remlink(&but->link->lines, line); + + link= line->from->link; + + /* are there more pointers allowed? */ + if(link->ppoin) { + + if(*(link->totlink)==1) { + *(link->totlink)= 0; + MEM_freeN(*(link->ppoin)); + *(link->ppoin)= NULL; + } + else { + b= 0; + for(a=0; a< (*(link->totlink)); a++) { + + if( (*(link->ppoin))[a] != line->to->poin ) { + (*(link->ppoin))[b]= (*(link->ppoin))[a]; + b++; + } + } + (*(link->totlink))--; + } + } + else { + *(link->poin)= NULL; + } + + MEM_freeN(line); + } + line= nline; + } + } + but= but->next; + } + + /* temporal! these buttons can be everywhere... */ + allqueue(REDRAWBUTSLOGIC, 0); +} + +static void ui_do_active_linklines(uiBlock *block, short *mval) +{ + uiBut *but; + uiLinkLine *line, *act= NULL; + float mindist= 12.0, fac, v1[2], v2[2], v3[3]; + int foundone= 0; + + if(mval) { + v1[0]= mval[0]; + v1[1]= mval[1]; + + /* find a line close to the mouse */ + but= block->buttons.first; + while(but) { + if(but->type==LINK && but->link) { + foundone= 1; + line= but->link->lines.first; + while(line) { + v2[0]= line->from->x2; + v2[1]= (line->from->y1+line->from->y2)/2.0; + v3[0]= line->to->x1; + v3[1]= (line->to->y1+line->to->y2)/2.0; + + fac= PdistVL2Dfl(v1, v2, v3); + if(fac < mindist) { + mindist= fac; + act= line; + } + line= line->next; + } + } + but= but->next; + } + } + + /* check for a 'found one' to prevent going to 'frontbuffer' mode. + this slows done gfx quite some, and at OSX the 'finish' forces a swapbuffer */ + if(foundone) { + glDrawBuffer(GL_FRONT); + + /* draw */ + but= block->buttons.first; + while(but) { + if(but->type==LINK && but->link) { + line= but->link->lines.first; + while(line) { + if(line==act) { + if((line->flag & UI_SELECT)==0) { + line->flag |= UI_SELECT; + ui_draw_linkline(but, line); + } + } + else if(line->flag & UI_SELECT) { + line->flag &= ~UI_SELECT; + ui_draw_linkline(but, line); + } + line= line->next; + } + } + but= but->next; + } + bglFlush(); + glDrawBuffer(GL_BACK); + } +} +#endif + +/* ******************************************************* */ + +/* XXX 2.50 no screendump supported yet */ + +#if 0 +/* nasty but safe way to store screendump rect */ +static int scr_x=0, scr_y=0, scr_sizex=0, scr_sizey=0; + +static void ui_set_screendump_bbox(uiBlock *block) +{ + if(block) { + scr_x= block->minx; + scr_y= block->miny; + scr_sizex= block->maxx - block->minx; + scr_sizey= block->maxy - block->miny; + } + else { + scr_sizex= scr_sizey= 0; + } +} + +/* used for making screenshots for menus, called in screendump.c */ +int uiIsMenu(int *x, int *y, int *sizex, int *sizey) +{ + if(scr_sizex!=0 && scr_sizey!=0) { + *x= scr_x; + *y= scr_y; + *sizex= scr_sizex; + *sizey= scr_sizey; + return 1; + } + + return 0; +} +#endif + +/* *********************** data get/set *********************** + * this either works with the pointed to data, or can work with + * an edit override pointer while dragging for example */ + +/* for buttons pointing to color for example */ +void ui_get_but_vectorf(uiBut *but, float *vec) +{ + void *poin; + int pointype; + + poin= (but->editvec)? (void*)but->editvec: but->poin; + pointype= (but->editvec)? FLO: but->pointype; + + if(!but->editvec && pointype == CHA) { + char *cp= (char *)poin; + vec[0]= ((float)cp[0])/255.0; + vec[1]= ((float)cp[1])/255.0; + vec[2]= ((float)cp[2])/255.0; + } + else if(pointype == FLO) { + float *fp= (float *)poin; + VECCOPY(vec, fp); + } +} + +/* for buttons pointing to color for example */ +void ui_set_but_vectorf(uiBut *but, float *vec) +{ + void *poin; + int pointype; + + poin= (but->editvec)? (void*)but->editvec: but->poin; + pointype= (but->editvec)? FLO: but->pointype; + + if(!but->editvec && but->pointype == CHA) { + char *cp= (char *)poin; + cp[0]= (char)(0.5 +vec[0]*255.0); + cp[1]= (char)(0.5 +vec[1]*255.0); + cp[2]= (char)(0.5 +vec[2]*255.0); + } + else if( but->pointype == FLO ) { + float *fp= (float *)poin; + VECCOPY(fp, vec); + } +} + +int ui_is_but_float(uiBut *but) +{ + if(but->pointype==FLO && but->poin) + return 1; + + if(but->rnaprop && RNA_property_type(&but->rnapoin, but->rnaprop) == PROP_FLOAT) + return 1; + + return 0; +} + +double ui_get_but_val(uiBut *but) +{ + PropertyRNA *prop; + double value = 0.0; + + if(but->editval) { return *(but->editval); } + if(but->poin==NULL && but->rnapoin.data==NULL) return 0.0; + + if(but->rnaprop) { + prop= but->rnaprop; + + switch(RNA_property_type(&but->rnapoin, prop)) { + case PROP_BOOLEAN: + if(RNA_property_array_length(&but->rnapoin, prop)) + value= RNA_property_boolean_get_array(&but->rnapoin, prop, but->rnaindex); + else + value= RNA_property_boolean_get(&but->rnapoin, prop); + break; + case PROP_INT: + if(RNA_property_array_length(&but->rnapoin, prop)) + value= RNA_property_int_get_array(&but->rnapoin, prop, but->rnaindex); + else + value= RNA_property_int_get(&but->rnapoin, prop); + break; + case PROP_FLOAT: + if(RNA_property_array_length(&but->rnapoin, prop)) + value= RNA_property_float_get_array(&but->rnapoin, prop, but->rnaindex); + else + value= RNA_property_float_get(&but->rnapoin, prop); + break; + case PROP_ENUM: + value= RNA_property_enum_get(&but->rnapoin, prop); + break; + default: + value= 0.0; + break; + } + } + else if(but->type== HSVSLI) { + float h, s, v, *fp; + + fp= (but->editvec)? but->editvec: (float *)but->poin; + rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v); + + switch(but->str[0]) { + case 'H': value= h; break; + case 'S': value= s; break; + case 'V': value= v; break; + } + } + else if( but->pointype == CHA ) { + value= *(char *)but->poin; + } + else if( but->pointype == SHO ) { + value= *(short *)but->poin; + } + else if( but->pointype == INT ) { + value= *(int *)but->poin; + } + else if( but->pointype == FLO ) { + value= *(float *)but->poin; + } + + return value; +} + +void ui_set_but_val(uiBut *but, double value) +{ + PropertyRNA *prop; + + /* value is a hsv value: convert to rgb */ + if(but->rnaprop) { + prop= but->rnaprop; + + if(RNA_property_editable(&but->rnapoin, prop)) { + switch(RNA_property_type(&but->rnapoin, prop)) { + case PROP_BOOLEAN: + if(RNA_property_array_length(&but->rnapoin, prop)) + RNA_property_boolean_set_array(&but->rnapoin, prop, but->rnaindex, value); + else + RNA_property_boolean_set(&but->rnapoin, prop, value); + break; + case PROP_INT: + if(RNA_property_array_length(&but->rnapoin, prop)) + RNA_property_int_set_array(&but->rnapoin, prop, but->rnaindex, value); + else + RNA_property_int_set(&but->rnapoin, prop, value); + break; + case PROP_FLOAT: + if(RNA_property_array_length(&but->rnapoin, prop)) + RNA_property_float_set_array(&but->rnapoin, prop, but->rnaindex, value); + else + RNA_property_float_set(&but->rnapoin, prop, value); + break; + case PROP_ENUM: + RNA_property_enum_set(&but->rnapoin, prop, value); + break; + default: + break; + } + } + } + else if(but->pointype==0); + else if(but->type==HSVSLI ) { + float h, s, v, *fp; + + fp= (but->editvec)? but->editvec: (float *)but->poin; + rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v); + + switch(but->str[0]) { + case 'H': h= value; break; + case 'S': s= value; break; + case 'V': v= value; break; + } + + hsv_to_rgb(h, s, v, fp, fp+1, fp+2); + + } + else { + /* first do rounding */ + if(but->pointype==CHA) + value= (char)floor(value+0.5); + else if(but->pointype==SHO ) { + /* gcc 3.2.1 seems to have problems + * casting a double like 32772.0 to + * a short so we cast to an int, then + to a short */ + int gcckludge; + gcckludge = (int) floor(value+0.5); + value= (short)gcckludge; + } + else if(but->pointype==INT ) + value= (int)floor(value+0.5); + else if(but->pointype==FLO ) { + float fval= (float)value; + if(fval>= -0.00001f && fval<= 0.00001f) fval= 0.0f; /* prevent negative zero */ + value= fval; + } + + /* then set value with possible edit override */ + if(but->editval) + *but->editval= value; + else if(but->pointype==CHA) + *((char *)but->poin)= (char)value; + else if(but->pointype==SHO) + *((short *)but->poin)= (short)value; + else if(but->pointype==INT) + *((int *)but->poin)= (int)value; + else if(but->pointype==FLO) + *((float *)but->poin)= (float)value; + } + + /* update select flag */ + ui_is_but_sel(but); +} + +void ui_get_but_string(uiBut *but, char *str, int maxlen) +{ + if(but->rnaprop) { + char *buf; + + buf= RNA_property_string_get_alloc(&but->rnapoin, but->rnaprop, str, maxlen); + + if(buf != str) { + /* string was too long, we have to truncate */ + BLI_strncpy(str, buf, maxlen); + MEM_freeN(buf); + } + } + else + BLI_strncpy(str, but->poin, maxlen); + +} + +void ui_set_but_string(uiBut *but, const char *str) +{ + if(but->rnaprop) { + if(RNA_property_editable(&but->rnapoin, but->rnaprop)) + RNA_property_string_set(&but->rnapoin, but->rnaprop, str); + } + else + BLI_strncpy(but->poin, str, but->max); +} + +/* ******************* Font ********************/ + +static void ui_set_ftf_font(float aspect) +{ +#ifdef INTERNATIONAL + if(aspect<1.15) { + FTF_SetFontSize('l'); + } + else if(aspect<1.59) { + FTF_SetFontSize('m'); + } + else { + FTF_SetFontSize('s'); + } +#endif +} + +void uiSetCurFont(uiBlock *block, int index) +{ + ui_set_ftf_font(block->aspect); + + if(block->aspect<0.60) { + block->curfont= UIfont[index].xl; + } + else if(block->aspect<1.15) { + block->curfont= UIfont[index].large; + } + else if(block->aspect<1.59) { + block->curfont= UIfont[index].medium; + } + else { + block->curfont= UIfont[index].small; + } + + if(block->curfont==NULL) block->curfont= UIfont[index].large; + if(block->curfont==NULL) block->curfont= UIfont[index].medium; + if(block->curfont==NULL) printf("error block no font %s\n", block->name); + +} + +/* called by node editor */ +void *uiSetCurFont_ext(float aspect) +{ + void *curfont; + + ui_set_ftf_font(aspect); + + if(aspect<0.60) { + curfont= UIfont[0].xl; + } + else if(aspect<1.15) { + curfont= UIfont[0].large; + } + else if(aspect<1.59) { + curfont= UIfont[0].medium; + } + else { + curfont= UIfont[0].small; + } + + if(curfont==NULL) curfont= UIfont[0].large; + if(curfont==NULL) curfont= UIfont[0].medium; + + return curfont; +} + +void uiDefFont(unsigned int index, void *xl, void *large, void *medium, void *small) +{ + if(index>=UI_ARRAY) return; + + UIfont[index].xl= xl; + UIfont[index].large= large; + UIfont[index].medium= medium; + UIfont[index].small= small; +} + +/* ******************* Free ********************/ + +static void ui_free_link(uiLink *link) +{ + if(link) { + BLI_freelistN(&link->lines); + MEM_freeN(link); + } +} + +static void ui_free_but(const bContext *C, uiBut *but) +{ + if(but->active) ui_button_active_cancel(C, but); + if(but->str && but->str != but->strdata) MEM_freeN(but->str); + ui_free_link(but->link); + + MEM_freeN(but); +} + +void uiFreeBlock(const bContext *C, uiBlock *block) +{ + uiBut *but; + + while( (but= block->buttons.first) ) { + BLI_remlink(&block->buttons, but); + ui_free_but(C, but); + } + + if(block->panel) block->panel->active= 0; + BLI_freelistN(&block->saferct); + + + MEM_freeN(block); +} + +void uiFreeBlocks(const bContext *C, ListBase *lb) +{ + uiBlock *block; + + while( (block= lb->first) ) { + BLI_remlink(lb, block); + uiFreeBlock(C, block); + } +} + +uiBlock *uiBeginBlock(const bContext *C, ARegion *region, char *name, short dt, short font) +{ + ListBase *lb; + uiBlock *block, *oldblock= NULL; + wmWindow *window; + int getsizex, getsizey; + + window= C->window; + lb= ®ion->uiblocks; + + /* each listbase only has one block with this name, free block + * if is already there so it can be rebuilt from scratch */ + if(lb) { + for (oldblock= lb->first; oldblock; oldblock= oldblock->next) + if (BLI_streq(oldblock->name, name)) + break; + + if (oldblock) + BLI_remlink(lb, oldblock); + } + + block= MEM_callocN(sizeof(uiBlock), "uiBlock"); + block->oldblock= oldblock; + + /* at the beginning of the list! for dynamical menus/blocks */ + if(lb) + BLI_addhead(lb, block); + + BLI_strncpy(block->name, name, sizeof(block->name)); + +#if 0 + /* draw win */ + block->win= win; + /* window where queue event should be added, pretty weak this way! + this is because the 'mainwin' pup menu's */ + block->winq= mywinget(); +#endif + + block->dt= dt; + block->themecol= TH_AUTO; + + /* window matrix and aspect */ + if(region->swinid) { + wm_subwindow_getmatrix(window, region->swinid, block->winmat); + wm_subwindow_getsize(window, region->swinid, &getsizex, &getsizey); + + /* TODO - investigate why block->winmat[0][0] is negative + * in the image view when viewRedrawForce is called */ + block->aspect= 2.0/fabs( (getsizex)*block->winmat[0][0]); + } + else { + /* no subwindow created yet, for menus for example, so we + * use the main window instead, since buttons are created + * there anyway */ + wm_subwindow_getmatrix(window, window->winid, block->winmat); + wm_subwindow_getsize(window, window->winid, &getsizex, &getsizey); + + block->aspect= 2.0/fabs(getsizex*block->winmat[0][0]); + block->auto_open= 2; + } + + uiSetCurFont(block, font); + + return block; +} + +uiBlock *uiGetBlock(char *name, ARegion *ar) +{ + uiBlock *block= ar->uiblocks.first; + + while(block) { + if( strcmp(name, block->name)==0 ) return block; + block= block->next; + } + + return NULL; +} + +void ui_check_but(uiBut *but) +{ + /* if something changed in the button */ + ID *id; + double value; + float okwidth; + int transopts= ui_translate_buttons(); + short pos; + + ui_is_but_sel(but); + + if(but->type==TEX || but->type==IDPOIN) transopts= 0; + + /* test for min and max, icon sliders, etc */ + switch( but->type ) { + case NUM: + case SLI: + case SCROLL: + case NUMSLI: + case HSVSLI: + value= ui_get_but_val(but); + if(value < but->min) ui_set_but_val(but, but->min); + else if(value > but->max) ui_set_but_val(but, but->max); + break; + + case NUMABS: + value= fabs( ui_get_but_val(but) ); + if(value < but->min) ui_set_but_val(but, but->min); + else if(value > but->max) ui_set_but_val(but, but->max); + break; + + case ICONTOG: + case ICONTOGN: + if(but->flag & UI_SELECT) but->iconadd= 1; + else but->iconadd= 0; + break; + + case ICONROW: + value= ui_get_but_val(but); + but->iconadd= (int)value- (int)(but->min); + break; + + case ICONTEXTROW: + value= ui_get_but_val(but); + but->iconadd= (int)value- (int)(but->min); + break; + } + + + /* safety is 4 to enable small number buttons (like 'users') */ + if(but->type==NUMSLI || but->type==HSVSLI) + okwidth= -4 + (but->x2 - but->x1)/2.0; + else + okwidth= -4 + (but->x2 - but->x1); + + /* name: */ + switch( but->type ) { + + case MENU: + case ICONTEXTROW: + + if(but->x2 - but->x1 > 24) { + value= ui_get_but_val(but); + ui_set_name_menu(but, (int)value); + } + break; + + case NUM: + case NUMSLI: + case HSVSLI: + case NUMABS: + + value= ui_get_but_val(but); + + if(ui_is_but_float(but)) { + if(value == FLT_MAX) sprintf(but->drawstr, "%sFLT_MAX", but->str); + else if(value == -FLT_MAX) sprintf(but->drawstr, "%s-FLT_MAX", but->str); + else if(but->a2) { /* amount of digits defined */ + if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value); + else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value); + else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value); + else sprintf(but->drawstr, "%s%.4f", but->str, value); + } + else { + if(but->max<10.001) sprintf(but->drawstr, "%s%.3f", but->str, value); + else sprintf(but->drawstr, "%s%.2f", but->str, value); + } + } + else { + sprintf(but->drawstr, "%s%d", but->str, (int)value); + } + break; + + case LABEL: + if(ui_is_but_float(but)) { + value= ui_get_but_val(but); + if(but->a2) { /* amount of digits defined */ + if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value); + else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value); + else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value); + else sprintf(but->drawstr, "%s%.4f", but->str, value); + } + else { + sprintf(but->drawstr, "%s%.2f", but->str, value); + } + } + else strcpy(but->drawstr, but->str); + + break; + + case IDPOIN: + id= *(but->idpoin_idpp); + strcpy(but->drawstr, but->str); + if(id) strcat(but->drawstr, id->name+2); + break; + + case TEX: + if(!but->editstr) { + char str[UI_MAX_DRAW_STR]; + + ui_get_but_string(but, str, UI_MAX_DRAW_STR-strlen(but->str)); + + strcpy(but->drawstr, but->str); + strcat(but->drawstr, str); + } + break; + + case KEYEVT: + strcpy(but->drawstr, but->str); + if (but->flag & UI_SELECT) { + strcat(but->drawstr, "Press a key"); + } else { + /* XXX 2.50 function not supported */ + /* strcat(but->drawstr, key_event_to_string((short) ui_get_but_val(but))); */ + } + break; + + case BUT_TOGDUAL: + /* trying to get the dual-icon to left of text... not very nice */ + if(but->str[0]) { + strcpy(but->drawstr, " "); + strcpy(but->drawstr+2, but->str); + } + break; + default: + strcpy(but->drawstr, but->str); + + } + + /* if we are doing text editing, this will override the drawstr */ + if(but->editstr) { + strcpy(but->drawstr, but->str); + strcat(but->drawstr, but->editstr); + } + + if(but->drawstr[0]) { + but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts); + // here should be check for less space for icon offsets... + if(but->type==MENU) okwidth -= 15; + } + else + but->strwidth= 0; + + /* automatic width */ + if(but->x2==0.0f && but->x1 > 0.0f) { + but->x2= (but->x1+but->strwidth+6); + } + + if(but->strwidth==0) but->drawstr[0]= 0; + else if(but->type==BUTM || but->type==BLOCK); // no clip string, uiTextBoundsBlock is used (hack!) + else { + + /* calc but->ofs, to draw the string shorter if too long */ + but->ofs= 0; + + while(but->strwidth > (int)okwidth ) { + + if ELEM3(but->type, NUM, NUMABS, TEX) { // only these cut off left + but->ofs++; + but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr+but->ofs, transopts); + + /* textbut exception */ + if(but->editstr && but->pos != -1) { + pos= but->pos+strlen(but->str); + if(pos-1 < but->ofs) { + pos= but->ofs-pos+1; + but->ofs -= pos; + if(but->ofs<0) { + but->ofs= 0; + pos--; + } + but->drawstr[ strlen(but->drawstr)-pos ]= 0; + } + } + } + else { + but->drawstr[ strlen(but->drawstr)-1 ]= 0; + but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts); + } + + if(but->strwidth < 10) break; + } + } +} + +static int ui_auto_themecol(uiBut *but) +{ + + switch(but->type) { + case BUT: + return TH_BUT_ACTION; + case ROW: + case TOG: + case TOG3: + case TOGR: + case TOGN: + case BUT_TOGDUAL: + return TH_BUT_SETTING; + case SLI: + case NUM: + case NUMSLI: + case NUMABS: + case HSVSLI: + return TH_BUT_NUM; + case TEX: + return TH_BUT_TEXTFIELD; + case PULLDOWN: + case BLOCK: + case MENU: + case BUTM: + // (weak!) detect if it is a blockloop + if(but->block->dt == UI_EMBOSSP) return TH_MENU_ITEM; + return TH_BUT_POPUP; + case ROUNDBOX: + return TH_PANEL; + default: + return TH_BUT_NEUTRAL; + } +} + +void uiBlockBeginAlign(uiBlock *block) +{ + /* if other align was active, end it */ + if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block); + + block->flag |= UI_BUT_ALIGN_DOWN; + /* buttons declared after this call will this align flag */ +} + +static int buts_are_horiz(uiBut *but1, uiBut *but2) +{ + float dx, dy; + + dx= fabs( but1->x2 - but2->x1); + dy= fabs( but1->y1 - but2->y2); + + if(dx > dy) return 0; + return 1; +} + +void uiBlockEndAlign(uiBlock *block) +{ + uiBut *prev, *but=NULL, *next; + int flag= 0, cols=0, rows=0; + int theme= UI_GetThemeValue(TH_BUT_DRAWTYPE); + + if ( !(ELEM3(theme, TH_MINIMAL, TH_SHADED, TH_ROUNDED)) ) { + block->flag &= ~UI_BUT_ALIGN; // all 4 flags + return; + } + + /* auto align: + - go back to first button of align start (ALIGN_DOWN) + - compare triples, and define flags + */ + prev= block->buttons.last; + while(prev) { + if( (prev->flag & UI_BUT_ALIGN_DOWN)) but= prev; + else break; + + if(but && but->next) { + if(buts_are_horiz(but, but->next)) cols++; + else rows++; + } + + prev= prev->prev; + } + if(but==NULL) return; + + /* rows==0: 1 row, cols==0: 1 collumn */ + + /* note; how it uses 'flag' in loop below (either set it, or OR it) is confusing */ + prev= NULL; + while(but) { + next= but->next; + + /* clear old flag */ + but->flag &= ~UI_BUT_ALIGN_DOWN; + + if(flag==0) { /* first case */ + if(next) { + if(buts_are_horiz(but, next)) { + if(rows==0) + flag= UI_BUT_ALIGN_RIGHT; + else + flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT; + } + else { + flag= UI_BUT_ALIGN_DOWN; + } + } + } + else if(next==NULL) { /* last case */ + if(prev) { + if(buts_are_horiz(prev, but)) { + if(rows==0) + flag= UI_BUT_ALIGN_LEFT; + else + flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT; + } + else flag= UI_BUT_ALIGN_TOP; + } + } + else if(buts_are_horiz(but, next)) { + /* check if this is already second row */ + if( prev && buts_are_horiz(prev, but)==0) { + flag |= UI_BUT_ALIGN_TOP; + /* exception case: bottom row */ + if(rows>0) { + uiBut *bt= but; + while(bt) { + if(bt->next && buts_are_horiz(bt, bt->next)==0 ) break; + bt= bt->next; + } + if(bt==0) flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT; + } + } + else flag |= UI_BUT_ALIGN_LEFT; + } + else { + if(cols==0) { + flag |= UI_BUT_ALIGN_TOP; + } + else { /* next button switches to new row */ + if( (flag & UI_BUT_ALIGN_TOP)==0) { /* stil top row */ + if(prev) + flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT; + else + flag |= UI_BUT_ALIGN_DOWN; + } + else + flag |= UI_BUT_ALIGN_TOP; + } + } + + but->flag |= flag; + + /* merge coordinates */ + if(prev) { + // simple cases + if(rows==0) { + but->x1= (prev->x2+but->x1)/2.0; + prev->x2= but->x1; + } + else if(cols==0) { + but->y2= (prev->y1+but->y2)/2.0; + prev->y1= but->y2; + } + else { + if(buts_are_horiz(prev, but)) { + but->x1= (prev->x2+but->x1)/2.0; + prev->x2= but->x1; + /* copy height too */ + but->y2= prev->y2; + } + else if(prev->prev && buts_are_horiz(prev->prev, prev)==0) { + /* the previous button is a single one in its row */ + but->y2= (prev->y1+but->y2)/2.0; + prev->y1= but->y2; + } + else { + /* the previous button is not a single one in its row */ + but->y2= prev->y1; + } + } + } + + prev= but; + but= next; + } + + block->flag &= ~UI_BUT_ALIGN; // all 4 flags +} + +#if 0 +static void uiBlockEndAligno(uiBlock *block) +{ + uiBut *but; + + /* correct last defined button */ + but= block->buttons.last; + if(but) { + /* vertical align case */ + if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_DOWN) ) { + but->flag &= ~UI_BUT_ALIGN_DOWN; + } + /* horizontal align case */ + if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_LEFT|UI_BUT_ALIGN_RIGHT) ) { + but->flag &= ~UI_BUT_ALIGN_RIGHT; + } + /* else do nothing, manually provided flags */ + } + block->flag &= ~UI_BUT_ALIGN; // all 4 flags +} +#endif + +/* +ui_def_but is the function that draws many button types + +for float buttons: + "a1" Click Step (how much to change the value each click) + "a2" Number of decimal point values to display. 0 defaults to 3 (0.000) 1,2,3, and a maximum of 4, + all greater values will be clamped to 4. + +*/ +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) +{ + uiBut *but; + short slen; + + if(type & BUTPOIN) { /* a pointer is required */ + if(poin==NULL) { + /* if pointer is zero, button is removed and not drawn */ + UI_ThemeColor(block->themecol); + glRects(x1, y1, x1+x2, y1+y2); + return NULL; + } + } + + but= MEM_callocN(sizeof(uiBut), "uiBut"); + + but->type= type & BUTTYPE; + but->pointype= type & BUTPOIN; + but->bit= type & BIT; + but->bitnr= type & 31; + but->icon = 0; + + BLI_addtail(&block->buttons, but); + + but->retval= retval; + if( strlen(str)>=UI_MAX_NAME_STR-1 ) { + but->str= MEM_callocN( strlen(str)+2, "uiDefBut"); + strcpy(but->str, str); + } + else { + but->str= but->strdata; + strcpy(but->str, str); + } + but->x1= x1; + but->y1= y1; + if(block->autofill) { + but->x2= x2; + but->y2= y2; + } + else { + but->x2= (x1+x2); + but->y2= (y1+y2); + } + but->poin= poin; + but->min= min; + but->max= max; + but->a1= a1; + but->a2= a2; + but->tip= tip; + + but->font= block->curfont; + + but->lock= block->lock; + but->lockstr= block->lockstr; + + but->aspect= block->aspect; + but->win= block->win; + but->block= block; // pointer back, used for frontbuffer status, and picker + + if(block->themecol==TH_AUTO) but->themecol= ui_auto_themecol(but); + else but->themecol= block->themecol; + + if(but->type != BUTM) { + but->func= block->func; + but->func_arg1= block->func_arg1; + but->func_arg2= block->func_arg2; + } + + ui_set_embossfunc(but, block->dt); + + but->pos= -1; /* cursor invisible */ + + if(ELEM(but->type, NUM, NUMABS)) { /* add a space to name */ + slen= strlen(but->str); + if(slen>0 && slen<UI_MAX_NAME_STR-2) { + if(but->str[slen-1]!=' ') { + but->str[slen]= ' '; + but->str[slen+1]= 0; + } + } + } + + if(but->type==HSVCUBE) { /* hsv buttons temp storage */ + float rgb[3]; + ui_get_but_vectorf(but, rgb); + rgb_to_hsv(rgb[0], rgb[1], rgb[2], but->hsv, but->hsv+1, but->hsv+2); + } + + if ELEM8(but->type, HSVSLI , NUMSLI, MENU, TEX, LABEL, IDPOIN, BLOCK, BUTM) { + but->flag |= UI_TEXT_LEFT; + } + + if(but->type==BUT_TOGDUAL) { + but->flag |= UI_ICON_LEFT; + } + + if(but->type==ROUNDBOX) + but->flag |= UI_NO_HILITE; + + but->flag |= (block->flag & UI_BUT_ALIGN); + if(block->flag & UI_BLOCK_NO_HILITE) + but->flag |= UI_NO_HILITE; + + return but; +} + +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) +{ + uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip); + + ui_check_but(but); + + return but; +} + + /* if _x_ is a power of two (only one bit) return the power, + * otherwise return -1. + * (1<<findBitIndex(x))==x for powers of two. + */ +static int findBitIndex(unsigned int x) { + if (!x || (x&(x-1))!=0) { /* x&(x-1) strips lowest bit */ + return -1; + } else { + int idx= 0; + + if (x&0xFFFF0000) idx+=16, x>>=16; + if (x&0xFF00) idx+=8, x>>=8; + if (x&0xF0) idx+=4, x>>=4; + if (x&0xC) idx+=2, x>>=2; + if (x&0x2) idx+=1; + + return idx; + } +} + +/* autocomplete helper functions */ +struct AutoComplete { + int maxlen; + char *truncate; + char *startname; +}; + +AutoComplete *autocomplete_begin(char *startname, int maxlen) +{ + AutoComplete *autocpl; + + autocpl= MEM_callocN(sizeof(AutoComplete), "AutoComplete"); + autocpl->maxlen= maxlen; + autocpl->truncate= MEM_callocN(sizeof(char)*maxlen, "AutoCompleteTruncate"); + autocpl->startname= startname; + + return autocpl; +} + +void autocomplete_do_name(AutoComplete *autocpl, const char *name) +{ + char *truncate= autocpl->truncate; + char *startname= autocpl->startname; + int a; + + for(a=0; a<autocpl->maxlen-1; a++) { + if(startname[a]==0 || startname[a]!=name[a]) + break; + } + /* found a match */ + if(startname[a]==0) { + /* first match */ + if(truncate[0]==0) + BLI_strncpy(truncate, name, autocpl->maxlen); + else { + /* remove from truncate what is not in bone->name */ + for(a=0; a<autocpl->maxlen-1; a++) { + if(truncate[a]!=name[a]) + truncate[a]= 0; + } + } + } +} + +void autocomplete_end(AutoComplete *autocpl, char *autoname) +{ + if(autocpl->truncate[0]) + BLI_strncpy(autoname, autocpl->truncate, autocpl->maxlen); + else + BLI_strncpy(autoname, autocpl->startname, autocpl->maxlen); + + MEM_freeN(autocpl->truncate); + MEM_freeN(autocpl); +} + +/* autocomplete callback for ID buttons */ +static void autocomplete_id(bContext *C, char *str, void *arg_v) +{ + /* int blocktype= (intptr_t)arg_v; */ + ListBase *listb= NULL /* XXX 2.50 needs context, wich_libbase(G.main, blocktype) */; + + if(listb==NULL) return; + + /* search if str matches the beginning of an ID struct */ + if(str[0]) { + AutoComplete *autocpl= autocomplete_begin(str, 22); + ID *id; + + for(id= listb->first; id; id= id->next) + autocomplete_do_name(autocpl, id->name+2); + + autocomplete_end(autocpl, str); + } +} + +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) +{ + int bitIdx= findBitIndex(bit); + if (bitIdx==-1) { + return NULL; + } else { + return uiDefBut(block, type|BIT|bitIdx, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip); + } +} +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) +{ + return uiDefBut(block, type|FLO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefButBit(block, type|FLO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefBut(block, type|INT, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefButBit(block, type|INT, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefBut(block, type|SHO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefButBit(block, type|SHO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefBut(block, type|CHA, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefButBit(block, type|CHA, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} + +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) +{ + uiBut *but= ui_def_but(block, type, retval, "", x1, y1, x2, y2, poin, min, max, a1, a2, tip); + + but->icon= (BIFIconID) icon; + but->flag|= UI_HAS_ICON; + + ui_check_but(but); + + return but; +} +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) +{ + int bitIdx= findBitIndex(bit); + if (bitIdx==-1) { + return NULL; + } else { + return uiDefIconBut(block, type|BIT|bitIdx, retval, icon, x1, y1, x2, y2, poin, min, max, a1, a2, tip); + } +} + +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) +{ + return uiDefIconBut(block, type|FLO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconButBit(block, type|FLO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconBut(block, type|INT, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconButBit(block, type|INT, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconBut(block, type|SHO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconButBit(block, type|SHO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconBut(block, type|CHA, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconButBit(block, type|CHA, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} + +/* Button containing both string label and icon */ +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) +{ + uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip); + + but->icon= (BIFIconID) icon; + but->flag|= UI_HAS_ICON; + + but->flag|= UI_ICON_LEFT; + + ui_check_but(but); + + return but; +} +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) +{ + int bitIdx= findBitIndex(bit); + if (bitIdx==-1) { + return NULL; + } else { + return uiDefIconTextBut(block, type|BIT|bitIdx, retval, icon, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip); + } +} + +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) +{ + return uiDefIconTextBut(block, type|FLO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextButBit(block, type|FLO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextBut(block, type|INT, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextButBit(block, type|INT, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextBut(block, type|SHO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextButBit(block, type|SHO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextBut(block, type|CHA, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} +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) +{ + return uiDefIconTextButBit(block, type|CHA, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip); +} + +uiBut *uiDefRNABut(uiBlock *block, int retval, PointerRNA *ptr, PropertyRNA *prop, int index, short x1, short y1, short x2, short y2) +{ + uiBut *but; + + switch(RNA_property_type(ptr, prop)) { + case PROP_BOOLEAN: { + int value, length; + + length= RNA_property_array_length(ptr, prop); + + if(length) + value= RNA_property_boolean_get_array(ptr, prop, index); + else + value= RNA_property_boolean_get(ptr, prop); + + but= ui_def_but(block, TOG, 0, (value)? "True": "False", x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(ptr, prop)); + break; + } + case PROP_INT: { + int softmin, softmax, step; + + RNA_property_int_ui_range(ptr, prop, &softmin, &softmax, &step); + but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, softmin, softmax, step, 0, (char*)RNA_property_ui_description(ptr, prop)); + break; + } + case PROP_FLOAT: { + float softmin, softmax, step, precision; + + RNA_property_float_ui_range(ptr, prop, &softmin, &softmax, &step, &precision); + but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, softmin, softmax, step, precision, (char*)RNA_property_ui_description(ptr, prop)); + break; + } + case PROP_ENUM: { + const EnumPropertyItem *item; + DynStr *dynstr; + char *menu; + int i, totitem; + + RNA_property_enum_items(ptr, prop, &item, &totitem); + + dynstr= BLI_dynstr_new(); + BLI_dynstr_appendf(dynstr, "%s%%t", RNA_property_ui_name(ptr, prop)); + for(i=0; i<totitem; i++) + BLI_dynstr_appendf(dynstr, "|%s %%x%d", item[i].name, item[i].value); + menu= BLI_dynstr_get_cstring(dynstr); + BLI_dynstr_free(dynstr); + + but= ui_def_but(block, MENU, 0, menu, x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(ptr, prop)); + MEM_freeN(menu); + break; + } + case PROP_STRING: { + int maxlength; + + maxlength= RNA_property_string_maxlength(ptr, prop); + if(maxlength == 0) + /* interface code should ideally support unlimited length */ + maxlength= UI_MAX_DRAW_STR; + + but= ui_def_but(block, TEX, 0, "", x1, y1, x2, y2, NULL, 0, maxlength, 0, 0, (char*)RNA_property_ui_description(ptr, prop)); + break; + } + case PROP_POINTER: { + PointerRNA pptr; + PropertyRNA *nameprop; + char name[256]= "", *nameptr= name; + + RNA_property_pointer_get(ptr, prop, &pptr); + + if(pptr.data) { + nameprop= RNA_struct_name_property(&pptr); + if(pptr.type && nameprop) + nameptr= RNA_property_string_get_alloc(&pptr, nameprop, name, sizeof(name)); + else + strcpy(nameptr, "->"); + } + + but= ui_def_but(block, BUT, 0, nameptr, x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(ptr, prop)); + but->flag |= UI_TEXT_LEFT; + + if(nameptr != name) + MEM_freeN(nameptr); + + break; + } + default: + but= NULL; + break; + } + + if(but) { + but->rnapoin= *ptr; + but->rnaprop= prop; + but->rnaindex= index; + + ui_check_but(but); + } + + return but; +} + +/* END Button containing both string label and icon */ + +void uiAutoBlock(uiBlock *block, float minx, float miny, float sizex, float sizey, int flag) +{ + block->minx= minx; + block->maxx= minx+sizex; + block->miny= miny; + block->maxy= miny+sizey; + + block->autofill= flag; /* also check for if it has to be done */ + +} + +void uiSetButLink(uiBut *but, void **poin, void ***ppoin, short *tot, int from, int to) +{ + uiLink *link; + + link= but->link= MEM_callocN(sizeof(uiLink), "new uilink"); + + link->poin= poin; + link->ppoin= ppoin; + link->totlink= tot; + link->fromcode= from; + link->tocode= to; +} + +/* cruft to make uiBlock and uiBut private */ + +int uiBlocksGetYMin(ListBase *lb) +{ + uiBlock *block; + int min= 0; + + for (block= lb->first; block; block= block->next) + if (block==lb->first || block->miny<min) + min= block->miny; + + return min; +} + +int uiBlockGetCol(uiBlock *block) +{ + return block->themecol; +} +void uiBlockSetCol(uiBlock *block, int col) +{ + block->themecol= col; +} +void uiBlockSetEmboss(uiBlock *block, int emboss) +{ + block->dt= emboss; +} +void uiBlockSetDirection(uiBlock *block, int direction) +{ + block->direction= direction; +} + +/* this call escapes if there's alignment flags */ +void uiBlockFlipOrder(uiBlock *block) +{ + ListBase lb; + uiBut *but, *next; + float centy, miny=10000, maxy= -10000; + +// if(U.uiflag & USER_PLAINMENUS) +// return; + + for(but= block->buttons.first; but; but= but->next) { + if(but->flag & UI_BUT_ALIGN) return; + if(but->y1 < miny) miny= but->y1; + if(but->y2 > maxy) maxy= but->y2; + } + /* mirror trick */ + centy= (miny+maxy)/2.0; + for(but= block->buttons.first; but; but= but->next) { + but->y1 = centy-(but->y1-centy); + but->y2 = centy-(but->y2-centy); + SWAP(float, but->y1, but->y2); + } + + /* also flip order in block itself, for example for arrowkey */ + lb.first= lb.last= NULL; + but= block->buttons.first; + while(but) { + next= but->next; + BLI_remlink(&block->buttons, but); + BLI_addtail(&lb, but); + but= next; + } + block->buttons= lb; +} + + +void uiBlockSetFlag(uiBlock *block, int flag) +{ + block->flag= flag; +} +void uiBlockSetXOfs(uiBlock *block, int xofs) +{ + block->xofs= xofs; +} +void* uiBlockGetCurFont(uiBlock *block) +{ + return block->curfont; +} + +void uiButSetFlag(uiBut *but, int flag) +{ + but->flag|= flag; +} +void uiButClearFlag(uiBut *but, int flag) +{ + but->flag&= ~flag; +} + +int uiButGetRetVal(uiBut *but) +{ + return but->retval; +} + +void uiBlockSetHandleFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int event), void *arg) +{ + block->handle_func= func; + block->handle_func_arg= arg; +} + +void uiBlockSetButmFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int but_a2), void *arg) +{ + block->butm_func= func; + block->butm_func_arg= arg; +} + +void uiBlockSetFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2) +{ + block->func= func; + block->func_arg1= arg1; + block->func_arg2= arg2; +} + +void uiBlockSetDrawExtraFunc(uiBlock *block, void (*func)()) +{ + block->drawextra= func; +} + +void uiButSetFunc(uiBut *but, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2) +{ + but->func= func; + but->func_arg1= arg1; + but->func_arg2= arg2; +} + +void uiButSetCompleteFunc(uiBut *but, void (*func)(struct bContext *C, char *str, void *arg), void *arg) +{ + but->autocomplete_func= func; + but->autofunc_arg= arg; +} + +uiBut *uiDefIDPoinBut(uiBlock *block, uiIDPoinFuncFP func, short blocktype, int retval, char *str, short x1, short y1, short x2, short y2, void *idpp, char *tip) +{ + uiBut *but= ui_def_but(block, IDPOIN, retval, str, x1, y1, x2, y2, NULL, 0.0, 0.0, 0.0, 0.0, tip); + but->idpoin_func= func; + but->idpoin_idpp= (ID**) idpp; + ui_check_but(but); + + if(blocktype) + uiButSetCompleteFunc(but, autocomplete_id, (void *)(intptr_t)blocktype); + + return but; +} + +uiBut *uiDefBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip) +{ + uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip); + but->block_func= func; + ui_check_but(but); + return but; +} + +uiBut *uiDefPulldownBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip) +{ + uiBut *but= ui_def_but(block, PULLDOWN, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip); + but->block_func= func; + ui_check_but(but); + return but; +} + +/* Block button containing both string label and icon */ +uiBut *uiDefIconTextBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int icon, char *str, short x1, short y1, short x2, short y2, char *tip) +{ + uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip); + + but->icon= (BIFIconID) icon; + but->flag|= UI_HAS_ICON; + + but->flag|= UI_ICON_LEFT; + but->flag|= UI_ICON_RIGHT; + + but->block_func= func; + ui_check_but(but); + + return but; +} + +/* Block button containing icon */ +uiBut *uiDefIconBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int retval, int icon, short x1, short y1, short x2, short y2, char *tip) +{ + uiBut *but= ui_def_but(block, BLOCK, retval, "", x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip); + + but->icon= (BIFIconID) icon; + but->flag|= UI_HAS_ICON; + + but->flag|= UI_ICON_LEFT; + but->flag|= UI_ICON_RIGHT; + + but->block_func= func; + ui_check_but(but); + + return but; +} + +void uiDefKeyevtButS(uiBlock *block, int retval, char *str, short x1, short y1, short x2, short y2, short *spoin, char *tip) +{ + uiBut *but= ui_def_but(block, KEYEVT|SHO, retval, str, x1, y1, x2, y2, spoin, 0.0, 0.0, 0.0, 0.0, tip); + ui_check_but(but); +} + +/* Program Init/Exit */ + +void UI_init(void) +{ + uiDefFont(UI_HELVB, + BMF_GetFont(BMF_kHelveticaBold14), + BMF_GetFont(BMF_kHelveticaBold12), + BMF_GetFont(BMF_kHelveticaBold10), + BMF_GetFont(BMF_kHelveticaBold8)); + uiDefFont(UI_HELV, + BMF_GetFont(BMF_kHelvetica12), + BMF_GetFont(BMF_kHelvetica12), + BMF_GetFont(BMF_kHelvetica10), + BMF_GetFont(BMF_kHelveticaBold8)); + + ui_resources_init(); +} + +void UI_init_userdef() +{ + ui_text_init_userdef(); + ui_theme_init_userdef(); +} + +void UI_exit(void) +{ + ui_resources_free(); +} + |