/** * $Id$ * * ***** BEGIN GPL/BL DUAL 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. The Blender * Foundation also sells licenses for use in proprietary software under * the Blender License. See http://www.blender.org/BL/ for information * about this. * * 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/BL DUAL LICENSE BLOCK ***** */ /* a full doc with API notes can be found in bf-blender/blender/doc/interface_API.txt */ #include #include #include #include #ifdef HAVE_CONFIG_H #include #endif #ifndef WIN32 #include #else #include #include "BLI_winstuff.h" #endif #include "MEM_guardedalloc.h" #include "PIL_time.h" #include "BMF_Api.h" #include "BIF_language.h" #ifdef INTERNATIONAL #include "FTF_Api.h" #endif // INTERNATIONAL #include "BLI_blenlib.h" #include "BLI_arithb.h" #include "DNA_screen_types.h" #include "DNA_space_types.h" #include "DNA_userdef_types.h" #include "DNA_vec_types.h" #include "BKE_blender.h" #include "BKE_utildefines.h" #include "BKE_global.h" #include "BIF_gl.h" #include "BIF_graphics.h" #include "BIF_keyval.h" #include "BIF_mainqueue.h" #include "BIF_resources.h" #include "BIF_screen.h" #include "BIF_toolbox.h" #include "BIF_mywindow.h" #include "BIF_space.h" #include "BIF_glutil.h" #include "BIF_interface.h" #include "BIF_butspace.h" #include "BSE_view.h" #include "mydevice.h" #include "interface.h" #include "blendef.h" /* naming conventions: * * uiBlahBlah() external function * ui_blah_blah() internal function */ /***/ /* ************ GLOBALS ************* */ float UIwinmat[4][4]; static int UIlock= 0, UIafterval; static char *UIlockstr=NULL; static void (*UIafterfunc)(void *arg, int event); static void *UIafterfunc_arg; static uiFont UIfont[UI_ARRAY]; // no init needed uiBut *UIbuttip; /* ************* PROTOTYPES ***************** */ static void ui_set_but_val(uiBut *but, double value); static void ui_set_ftf_font(uiBlock *block); static void ui_do_but_tip(uiBut *buttip); /* ****************************** */ static int uibut_contains_pt(uiBut *but, short *pt) { return ((but->x1x2>=pt[0]) && (but->y1y2>=pt[1])); } static void uibut_do_func(uiBut *but) { if (but->func) { but->func(but->func_arg1, but->func_arg2); } } /* ************* window matrix ************** */ void ui_graphics_to_window(int win, float *x, float *y) /* for rectwrite */ { float gx, gy; int sx, sy; int getsizex, getsizey; bwin_getsize(win, &getsizex, &getsizey); bwin_getsuborigin(win, &sx, &sy); gx= *x; gy= *y; *x= sx + getsizex*(0.5+ 0.5*(gx*UIwinmat[0][0]+ gy*UIwinmat[1][0]+ UIwinmat[3][0])); *y= sy + getsizey*(0.5+ 0.5*(gx*UIwinmat[0][1]+ gy*UIwinmat[1][1]+ UIwinmat[3][1])); } void ui_window_to_graphics(int win, float *x, float *y) /* for mouse cursor */ { float a, b, c, d, e, f, px, py; int getsizex, getsizey; bwin_getsize(win, &getsizex, &getsizey); a= .5*getsizex*UIwinmat[0][0]; b= .5*getsizex*UIwinmat[1][0]; c= .5*getsizex*(1.0+UIwinmat[3][0]); d= .5*getsizey*UIwinmat[0][1]; e= .5*getsizey*UIwinmat[1][1]; f= .5*getsizey*(1.0+UIwinmat[3][1]); px= *x; py= *y; *y= (a*(py-f) + d*(c-px))/(a*e-d*b); *x= (px- b*(*y)- c)/a; } /* ************* SAVE UNDER ************ */ typedef struct { short x, y, sx, sy, oldwin; int oldcursor; unsigned int *rect; } uiSaveUnder; static void ui_paste_under(uiSaveUnder *su) { if(su) { glDisable(GL_DITHER); glRasterPos2f( su->x, su->y ); glDrawPixels(su->sx, su->sy, GL_RGBA, GL_UNSIGNED_BYTE, su->rect); glEnable(GL_DITHER); if(su->oldwin) { mywinset(su->oldwin); if (su->oldcursor) { set_cursor(su->oldcursor); } } MEM_freeN(su->rect); MEM_freeN(su); } } static uiSaveUnder *ui_save_under(int x, int y, int sx, int sy) { uiSaveUnder *su=NULL; if(sx>1 && sy>1) { su= MEM_callocN(sizeof(uiSaveUnder), "save under"); su->rect= MEM_mallocN(sx*sy*4, "temp_frontbuffer_image"); su->x= x; su->y= y; su->sx= sx; su->sy= sy; glReadPixels(x, y, sx, sy, GL_RGBA, GL_UNSIGNED_BYTE, su->rect); } return su; } static uiSaveUnder *ui_bgnpupdraw(int startx, int starty, int endx, int endy, int cursor) { uiSaveUnder *su; short oldwin; #if defined(__sgi) || defined(__sun) || defined(__sun__) || defined (__sparc) || defined (__sparc__) /* this is a dirty patch: gets sometimes the backbuffer */ my_get_frontbuffer_image(0, 0, 1, 1); my_put_frontbuffer_image(); #endif oldwin= mywinget(); mywinset(G.curscreen->mainwin); /* tinsy bit larger, 1 pixel on the edge */ glReadBuffer(GL_FRONT); glDrawBuffer(GL_FRONT); /* for geforce and other cards */ glFlush(); su= ui_save_under(startx-1, starty-1, endx-startx+2, endy-starty+6); if(su) su->oldwin= oldwin; if(su && cursor) { su->oldcursor= get_cursor(); set_cursor(CURSOR_STD); } return su; } static void ui_endpupdraw(uiSaveUnder *su) { /* for geforce and other cards */ glReadBuffer(GL_FRONT); glDrawBuffer(GL_FRONT); glFlush(); if(su) { ui_paste_under(su); } glReadBuffer(GL_BACK); glDrawBuffer(GL_BACK); } /* ******************* block calc ************************* */ void uiTextBoundsBlock(uiBlock *block, int addval) { uiBut *bt; int i = 0, j; bt= block->buttons.first; while(bt) { if(bt->type!=SEPR) { j= BIF_GetStringWidth(bt->font, bt->drawstr, (U.transopts & USER_TR_BUTTONS)); if(j > i) i = j; } bt= bt->next; } bt= block->buttons.first; while(bt) { bt->x2 = i + addval; ui_check_but(bt); // clips text again bt= bt->next; } } void uiBoundsBlock(uiBlock *block, int addval) { uiBut *bt; 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; } block->safety.xmin= block->minx-40; block->safety.ymin= block->miny-40; block->safety.xmax= block->maxx+40; block->safety.ymax= block->maxy+40; } static void ui_positionblock(uiBlock *block, uiBut *but) { /* position block relative to but */ uiBut *bt; rctf butrct; int xsize, ysize, xof=0, yof=0, centre; short dir1= 0, dir2=0; /* first transform to screen coords, assuming matrix is stil OK */ /* the UIwinmat is in panelspace */ butrct.xmin= but->x1; butrct.xmax= but->x2; butrct.ymin= but->y1; butrct.ymax= but->y2; ui_graphics_to_window(block->win, &butrct.xmin, &butrct.ymin); ui_graphics_to_window(block->win, &butrct.xmax, &butrct.ymax); block->parentrct= butrct; // will use that for pulldowns later /* calc block rect */ 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; } ui_graphics_to_window(block->win, &block->minx, &block->miny); ui_graphics_to_window(block->win, &block->maxx, &block->maxy); block->minx-= 2.0; block->miny-= 2.0; block->maxx+= 2.0; block->maxy+= 2.0; xsize= block->maxx - block->minx+4; // 4 for shadow ysize= block->maxy - block->miny+4; if(but) { short left=0, right=0, top=0, down=0; if(block->direction & UI_CENTRE) centre= ysize/2; else centre= 0; if( butrct.xmin-xsize > 0.0) left= 1; if( butrct.xmax+xsize < G.curscreen->sizex) right= 1; if( butrct.ymin-ysize+centre > 0.0) down= 1; if( butrct.ymax+ysize-centre < G.curscreen->sizey) top= 1; dir1= block->direction & UI_DIRECTION; /* secundary directions */ if(dir1 & (UI_TOP|UI_DOWN)) { if(dir1 & UI_LEFT) dir2= UI_LEFT; else if(dir1 & UI_RIGHT) dir2= UI_RIGHT; dir1 &= (UI_TOP|UI_DOWN); } if(dir2==0) if(dir1==UI_LEFT || dir1==UI_RIGHT) dir2= UI_DOWN; if(dir2==0) if(dir1==UI_TOP || dir1==UI_DOWN) dir2= UI_LEFT; /* no space at all? dont change */ if(left || right) { if(dir1==UI_LEFT && left==0) dir1= UI_RIGHT; if(dir1==UI_RIGHT && right==0) dir1= UI_LEFT; /* this is aligning, not append! */ if(dir2==UI_LEFT && right==0) dir2= UI_RIGHT; if(dir2==UI_RIGHT && left==0) dir2= UI_LEFT; } if(down || top) { if(dir1==UI_TOP && top==0) dir1= UI_DOWN; if(dir1==UI_DOWN && down==0) dir1= UI_TOP; if(dir2==UI_TOP && top==0) dir2= UI_DOWN; if(dir2==UI_DOWN && down==0) dir2= UI_TOP; } if(dir1==UI_LEFT) { xof= butrct.xmin - block->maxx; if(dir2==UI_TOP) yof= butrct.ymin - block->miny-centre; else yof= butrct.ymax - block->maxy+centre; } else if(dir1==UI_RIGHT) { xof= butrct.xmax - block->minx; if(dir2==UI_TOP) yof= butrct.ymin - block->miny-centre; else yof= butrct.ymax - block->maxy+centre; } else if(dir1==UI_TOP) { yof= butrct.ymax - block->miny-1; if(dir2==UI_RIGHT) xof= butrct.xmax - block->maxx; else xof= butrct.xmin - block->minx; // changed direction? if((dir1 & block->direction)==0) { if(block->direction & UI_SHIFT_FLIPPED) xof+= dir2==UI_LEFT?25:-25; uiBlockFlipOrder(block); } } else if(dir1==UI_DOWN) { yof= butrct.ymin - block->maxy+1; if(dir2==UI_RIGHT) xof= butrct.xmax - block->maxx; else xof= butrct.xmin - block->minx; // changed direction? if((dir1 & block->direction)==0) { if(block->direction & UI_SHIFT_FLIPPED) xof+= dir2==UI_LEFT?25:-25; uiBlockFlipOrder(block); } } // apply requested offset in the block xof += block->xofs/block->aspect; yof += block->yofs/block->aspect; } /* apply */ bt= block->buttons.first; while(bt) { ui_graphics_to_window(block->win, &bt->x1, &bt->y1); ui_graphics_to_window(block->win, &bt->x2, &bt->y2); bt->x1 += xof; bt->x2 += xof; bt->y1 += yof; bt->y2 += yof; bt->aspect= 1.0; // ui_check_but recalculates drawstring size in pixels ui_check_but(bt); bt= bt->next; } block->minx += xof; block->miny += yof; block->maxx += xof; block->maxy += yof; /* safety calculus */ if(but) { float midx= (block->parentrct.xmin+block->parentrct.xmax)/2.0; float midy= (block->parentrct.ymin+block->parentrct.ymax)/2.0; /* when you are outside parent button, safety there should be smaller */ // parent button to left if( midx < block->minx ) block->safety.xmin= block->minx-3; else block->safety.xmin= block->minx-40; // parent button to right if( midx > block->maxx ) block->safety.xmax= block->maxx+3; else block->safety.xmax= block->maxx+40; // parent button on bottom if( midy < block->miny ) block->safety.ymin= block->miny-3; else block->safety.ymin= block->miny-40; // parent button on top if( midy > block->maxy ) block->safety.ymax= block->maxy+3; else block->safety.ymax= block->maxy+40; // exception for switched pulldowns... if(dir1 && (dir1 & block->direction)==0) { if(dir2==UI_RIGHT) block->safety.xmax= block->maxx+3; if(dir2==UI_LEFT) block->safety.xmin= block->minx-3; } block->direction= dir1; } else { block->safety.xmin= block->minx-40; block->safety.ymin= block->miny-40; block->safety.xmax= block->maxx+40; block->safety.ymax= block->maxy+40; } } 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; imaxy; 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; if(but->block->frontbuf==UI_NEED_DRAW_FRONT) { but->block->frontbuf= UI_HAS_DRAW_FRONT; glDrawBuffer(GL_FRONT); if(but->win==curarea->headwin) curarea->head_swap= WIN_FRONT_OK; else curarea->win_swap= WIN_FRONT_OK; } 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) BIF_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 DRAWING FUNCTION ************* */ void uiDrawBlock(uiBlock *block) { uiBut *but; /* 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); uiPanelPush(block); // panel matrix if(block->flag & UI_BLOCK_LOOP) { uiDrawMenuBox(block->minx, block->miny, block->maxx, block->maxy, block->flag); } else if(block->panel) ui_draw_panel(block); if(block->drawextra) block->drawextra(); for (but= block->buttons.first; but; but= but->next) { ui_draw_but(but); } ui_draw_links(block); uiPanelPop(block); // matrix restored } /* ************* MENUBUTS *********** */ typedef struct { char *str; int retval; int icon; } MenuEntry; typedef struct { char *instr; char *title; MenuEntry *items; int nitems, itemssize; } MenuData; static MenuData *menudata_new(char *instr) { MenuData *md= MEM_mallocN(sizeof(*md), "MenuData"); md->instr= instr; md->title= NULL; md->items= NULL; md->nitems= md->itemssize= 0; return md; } static void menudata_set_title(MenuData *md, char *title) { if (!md->title) md->title= title; } static void menudata_add_item(MenuData *md, char *str, int retval, int icon) { if (md->nitems==md->itemssize) { int nsize= md->itemssize?(md->itemssize<<1):1; MenuEntry *oitems= md->items; md->items= MEM_mallocN(nsize*sizeof(*md->items), "md->items"); if (oitems) { memcpy(md->items, oitems, md->nitems*sizeof(*md->items)); MEM_freeN(oitems); } md->itemssize= nsize; } md->items[md->nitems].str= str; md->items[md->nitems].retval= retval; md->items[md->nitems].icon= icon; md->nitems++; } static void menudata_free(MenuData *md) { MEM_freeN(md->instr); if (md->items) MEM_freeN(md->items); MEM_freeN(md); } /** * Parse menu description strings, string is of the * form "[sss%t|]{(sss[%xNN]|), (%l|)}", ssss%t indicates the * menu title, sss or sss%xNN indicates an option, * if %xNN is given then NN is the return value if * that option is selected otherwise the return value * is the index of the option (starting with 1). %l * indicates a seperator. * * @param str String to be parsed. * @retval new menudata structure, free with menudata_free() */ static MenuData *decompose_menu_string(char *str) { char *instr= BLI_strdup(str); MenuData *md= menudata_new(instr); char *nitem= NULL, *s= instr; int nicon=0, nretval= 1, nitem_is_title= 0; while (1) { char c= *s; if (c=='%') { if (s[1]=='x') { nretval= atoi(s+2); *s= '\0'; s++; } else if (s[1]=='t') { nitem_is_title= 1; *s= '\0'; s++; } else if (s[1]=='l') { nitem= "%l"; s++; } else if (s[1]=='i') { nicon= atoi(s+2); s++; } } else if (c=='|' || c=='\0') { if (nitem) { *s= '\0'; if (nitem_is_title) { menudata_set_title(md, nitem); nitem_is_title= 0; } else { menudata_add_item(md, nitem, nretval, nicon); nretval= md->nitems+1; } nitem= NULL; nicon= 0; } if (c=='\0') break; } else if (!nitem) nitem= s; s++; } return md; } static void ui_set_name_menu(uiBut *but, int value) { MenuData *md; int i; md= decompose_menu_string(but->str); for (i=0; initems; i++) if (md->items[i].retval==value) strcpy(but->drawstr, md->items[i].str); menudata_free(md); } static void ui_warp_pointer(short x, short y) { /* OSX has very poor mousewarp support, it sends events; this causes a menu being pressed immediately ... */ #ifndef __APPLE__ warp_pointer(x, y); #endif } static int ui_do_but_MENU(uiBut *but) { uiBlock *block; uiBut *bt; ListBase listb={NULL, NULL}, lb; double fvalue; int width, height=0, a, xmax, starty; short startx; int columns=1, rows=0, boxh, event; short x1, y1, active= -1; short mval[2]; MenuData *md; but->flag |= UI_SELECT; ui_draw_but(but); block= uiNewBlock(&listb, "menu", UI_EMBOSSP, UI_HELV, but->win); block->flag= UI_BLOCK_LOOP|UI_BLOCK_REDRAW|UI_BLOCK_NUMSELECT; block->themecol= TH_MENU_ITEM; md= decompose_menu_string(but->str); /* columns and row calculation */ columns= (md->nitems+20)/20; if (columns<1) columns= 1; rows= (int) md->nitems/columns; if (rows<1) rows= 1; while (rows*columnsnitems) rows++; /* size and location */ if(md->title) width= 1.5*but->aspect*strlen(md->title)+BIF_GetStringWidth(block->curfont, md->title, (U.transopts & USER_TR_MENUS)); else width= 0; for(a=0; anitems; a++) { xmax= but->aspect*BIF_GetStringWidth(block->curfont, md->items[a].str, (U.transopts & USER_TR_MENUS)); if(xmax>width) width= xmax; } width+= 10; if (width < (but->x2 - but->x1)) width = (but->x2 - but->x1); if (width<50) width=50; boxh= TBOXH; height= rows*boxh; if (md->title) height+= boxh; getmouseco_sc(mval); /* find active item */ fvalue= ui_get_but_val(but); for(active=0; activenitems; active++) { if( md->items[active].retval== (int)fvalue ) break; } /* no active item? */ if(active==md->nitems) { if(md->title) active= -1; else active= 0; } /* for now disabled... works confusing because you think it's a title or so.... */ active= -1; /* here we go! */ startx= but->x1; starty= but->y1; if(md->title) { uiBut *bt; uiSetCurFont(block, block->font+1); bt= uiDefBut(block, LABEL, 0, md->title, startx, (short)(starty+rows*boxh), (short)width, (short)boxh, NULL, 0.0, 0.0, 0, 0, ""); uiSetCurFont(block, block->font); bt->flag= UI_TEXT_LEFT; } for(a=0; anitems; a++) { x1= but->x1 + width*((int)(md->nitems-a-1)/rows); y1= but->y1 - boxh*(rows - ((md->nitems - a - 1)%rows)) + (rows*boxh); if (strcmp(md->items[md->nitems-a-1].str, "%l")==0) { uiDefBut(block, SEPR, B_NOP, "", x1, y1,(short)(width-(rows>1)), (short)(boxh-1), NULL, 0.0, 0.0, 0, 0, ""); } else if(md->items[md->nitems-a-1].icon) { uiBut *bt= uiDefIconTextBut(block, BUTM|but->pointype, but->retval, md->items[md->nitems-a-1].icon ,md->items[md->nitems-a-1].str, x1, y1,(short)(width-(rows>1)), (short)(boxh-1), but->poin, (float) md->items[md->nitems-a-1].retval, 0.0, 0, 0, ""); if(active==a) bt->flag |= UI_ACTIVE; } else { uiBut *bt= uiDefBut(block, BUTM|but->pointype, but->retval, md->items[md->nitems-a-1].str, x1, y1,(short)(width-(rows>1)), (short)(boxh-1), but->poin, (float) md->items[md->nitems-a-1].retval, 0.0, 0, 0, ""); if(active==a) bt->flag |= UI_ACTIVE; } } /* the code up here has flipped locations, because of change of preferred order */ /* thats why we have to switch list order too, to make arrowkeys work */ lb.first= lb.last= NULL; bt= block->buttons.first; while(bt) { uiBut *next= bt->next; BLI_remlink(&block->buttons, bt); BLI_addhead(&lb, bt); bt= next; } block->buttons= lb; /* and lets go */ block->direction= UI_TOP; ui_positionblock(block, but); block->win= G.curscreen->mainwin; event= uiDoBlocks(&listb, 0); menudata_free(md); but->flag &= ~UI_SELECT; ui_check_but(but); ui_draw_but(but); uibut_do_func(but); return event; } /* ************* EVENTS ************* */ void uiGetMouse(int win, short *adr) { int x, y; float xwin, ywin; getmouseco_sc(adr); if (win == G.curscreen->mainwin) return; bwin_getsuborigin(win, &x, &y); adr[0]-= x; adr[1]-= y; xwin= adr[0]; ywin= adr[1]; ui_window_to_graphics(win, &xwin, &ywin); adr[0]= (short)(xwin+0.5); adr[1]= (short)(ywin+0.5); } 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 ) 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= 0; break; case KEYEVT: if (value==-1) push= 1; break; case TOG: case TOGR: case TOG3: case ICONTOG: if(value!=but->min) push= 1; break; 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; } static int ui_do_but_BUT(uiBut *but) { int activated; do { int oflag= but->flag; short mval[2]; uiGetMouse(mywinget(), mval); if (uibut_contains_pt(but, mval)) but->flag |= UI_SELECT; else but->flag &= ~UI_SELECT; if (but->flag != oflag) { ui_draw_but(but); glFlush(); // flush display in subloops } PIL_sleep_ms(10); } while (get_mbut() & L_MOUSE); activated= (but->flag & UI_SELECT); if(activated) { uibut_do_func(but); } but->flag &= ~UI_SELECT; ui_draw_but(but); return activated?but->retval:0; } static int ui_do_but_KEYEVT(uiBut *but) { unsigned short event= 0; short val; /* flag for ui_check_but */ ui_set_but_val(but, -1); ui_check_but(but); ui_draw_but(but); do { event= extern_qread(&val); } while (!event || !val || ELEM(event, MOUSEX, MOUSEY)); if (!key_event_to_string(event)[0]) event= 0; ui_set_but_val(but, (double) event); ui_check_but(but); ui_draw_but(but); return (event!=0); } static int ui_do_but_TOG(uiBlock *block, uiBut *but) { uiBut *bt; double value; int w, lvalue, push; value= ui_get_but_val(but); lvalue= (int)value; if(but->bit) { w= BTST(lvalue, but->bitnr); if(w) lvalue = BCLR(lvalue, but->bitnr); else lvalue = BSET(lvalue, but->bitnr); if(but->type==TOGR) { if( (get_qual() & LR_SHIFTKEY)==0 ) { lvalue= 1<<(but->bitnr); ui_set_but_val(but, (double)lvalue); bt= block->buttons.first; while(bt) { if( bt!=but && bt->poin==but->poin ) { ui_is_but_sel(bt); ui_draw_but(bt); } bt= bt->next; } } else { if(lvalue==0) lvalue= 1<<(but->bitnr); } } ui_set_but_val(but, (double)lvalue); if(but->type==ICONTOG) ui_check_but(but); // no frontbuffer draw for this one if((but->flag & UI_NO_HILITE)==0) ui_draw_but(but); } else { if(value==0.0) push= 1; else push= 0; if(but->type==TOGN) push= !push; ui_set_but_val(but, (double)push); if(but->type==ICONTOG) ui_check_but(but); // no frontbuffer draw for this one if((but->flag & UI_NO_HILITE)==0) ui_draw_but(but); } /* no while loop...this button is used for viewmove */ uibut_do_func(but); return but->retval; } static int ui_do_but_ROW(uiBlock *block, uiBut *but) { uiBut *bt; ui_set_but_val(but, but->max); ui_draw_but(but); bt= block->buttons.first; while(bt) { if( bt!=but && bt->type==ROW ) { if(bt->min==but->min) { ui_is_but_sel(bt); ui_draw_but(bt); } } bt= bt->next; } return but->retval; } static int ui_do_but_TEX(uiBut *but) { unsigned short dev; short x, mval[2], len=0, dodraw; char *str, backstr[UI_MAX_DRAW_STR]; short capturing; str= (char *)but->poin; but->flag |= UI_SELECT; uiGetMouse(mywinget(), mval); /* calculate cursor pos with current mousecoords */ BLI_strncpy(backstr, but->drawstr, UI_MAX_DRAW_STR); but->pos= strlen(backstr)-but->ofs; while((but->aspect*BIF_GetStringWidth(but->font, backstr+but->ofs, (U.transopts & USER_TR_BUTTONS)) + but->x1) > mval[0]) { if (but->pos <= 0) break; but->pos--; backstr[but->pos+but->ofs] = 0; } but->pos -= strlen(but->str); but->pos += but->ofs; if(but->pos<0) but->pos= 0; /* backup */ BLI_strncpy(backstr, but->poin, UI_MAX_DRAW_STR); ui_draw_but(but); glFlush(); // flush display in subloops while (get_mbut() & L_MOUSE) BIF_wait_for_statechange(); len= strlen(str); but->min= 0.0; capturing = TRUE; while(capturing) { char ascii; short val; dodraw= 0; dev = extern_qread_ext(&val, &ascii); if(dev==INPUTCHANGE) break; else if(get_mbut() & L_MOUSE) break; else if(get_mbut() & R_MOUSE) break; else if(dev==ESCKEY) break; else if(dev==MOUSEX) val= 0; else if(dev==MOUSEY) val= 0; if(ascii) { if(len < but->max) { for(x= but->max; x>but->pos; x--) str[x]= str[x-1]; str[but->pos]= ascii; but->pos++; len++; str[len]= '\0'; dodraw= 1; } } else if(val) { switch (dev) { case RIGHTARROWKEY: if(G.qual & LR_SHIFTKEY) but->pos= strlen(str); else but->pos++; if(but->pos>strlen(str)) but->pos= strlen(str); dodraw= 1; break; case LEFTARROWKEY: if(G.qual & LR_SHIFTKEY) but->pos= 0; else if(but->pos>0) but->pos--; dodraw= 1; break; case ENDKEY: but->pos= strlen(str); dodraw= 1; break; case HOMEKEY: but->pos= 0; dodraw= 1; break; case PADENTER: case RETKEY: capturing = FALSE; break; case DELKEY: if(but->pos>=0 && but->pospos; x<=strlen(str); x++) str[x]= str[x+1]; str[--len]='\0'; dodraw= 1; } break; case BACKSPACEKEY: if(len!=0) { if(get_qual() & LR_SHIFTKEY) { str[0]= 0; but->pos= 0; len= 0; dodraw= 1; } else if(but->pos>0) { for(x=but->pos; x<=strlen(str); x++) str[x-1]= str[x]; but->pos--; str[--len]='\0'; dodraw= 1; } } break; } } if(dodraw) { ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops } } if(dev==ESCKEY) strcpy(but->poin, backstr); but->pos= -1; but->flag &= ~UI_SELECT; uibut_do_func(but); ui_check_but(but); ui_draw_but(but); if(dev!=ESCKEY) return but->retval; else return 0; } static int uiActAsTextBut(uiBut *but) { void *but_func; double value; float min, max; int temp, retval, textleft; char str[UI_MAX_DRAW_STR], *point; value= ui_get_but_val(but); if( but->pointype==FLO ) { if(but->a2) { /* amount of digits defined */ if(but->a2==1) sprintf(str, "%.1f", value); else if(but->a2==2) sprintf(str, "%.2f", value); else if(but->a2==3) sprintf(str, "%.3f", value); else sprintf(str, "%.4f", value); } else sprintf(str, "%.3f", value); } else { sprintf(str, "%d", (int)value); } /* store values before calling as text button */ point= but->poin; but->poin= str; but_func= but->func; but->func= NULL; min= but->min; max= but->max; but->min= 0.0; but->max= 15.0; temp= but->type; but->type= TEX; textleft= but->flag & UI_TEXT_LEFT; but->flag |= UI_TEXT_LEFT; ui_check_but(but); retval= ui_do_but_TEX(but); /* restore values */ but->type= temp; but->poin= point; but->func= but_func; but->min= min; but->max= max; if(textleft==0) but->flag &= ~UI_TEXT_LEFT; if( but->pointype==FLO ) value= atof(str); else value= atoi(str); if(valuemax) value= max; ui_set_but_val(but, value); ui_check_but(but); ui_draw_but(but); return retval; } static int ui_do_but_NUM(uiBut *but) { double value; float deler, fstart, f, tempf; int lvalue, temp; /* , firsttime=1; */ short retval=0, qual, sx, mval[2], pos=0; but->flag |= UI_SELECT; ui_draw_but(but); glFlush(); // flush display before subloop uiGetMouse(mywinget(), mval); value= ui_get_but_val(but); sx= mval[0]; fstart= (value - but->min)/(but->max-but->min); f= fstart; temp= (int)value; tempf= value; if(get_qual() & LR_SHIFTKEY) { /* make it textbut */ if( uiActAsTextBut(but) ) retval= but->retval; } else { retval= but->retval; /* firsttime: this button can be approached with enter as well */ while (get_mbut() & L_MOUSE) { qual= get_qual(); deler= 500; if( but->pointype!=FLO ) { if( (but->max-but->min)<100 ) deler= 200.0; if( (but->max-but->min)<25 ) deler= 50.0; } if(qual & LR_SHIFTKEY) deler*= 10.0; if(qual & LR_ALTKEY) deler*= 20.0; uiGetMouse(mywinget(), mval); if(mval[0] != sx) { f+= ((float)(mval[0]-sx))/deler; if(f>1.0) f= 1.0; if(f<0.0) f= 0.0; sx= mval[0]; tempf= ( but->min + f*(but->max-but->min)); if( but->pointype!=FLO ) { temp= floor(tempf+.5); if(tempf==but->min || tempf==but->max); else if(qual & LR_CTRLKEY) temp= 10*(temp/10); if( temp>=but->min && temp<=but->max) { value= ui_get_but_val(but); lvalue= (int)value; if(temp != lvalue ) { pos= 1; ui_set_but_val(but, (double)temp); ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops uibut_do_func(but); } } } else { temp= 0; if(qual & LR_CTRLKEY) { if(tempf==but->min || tempf==but->max); else if(but->max-but->min < 2.10) tempf= 0.1*floor(10*tempf); else if(but->max-but->min < 21.0) tempf= floor(tempf); else tempf= 10.0*floor(tempf/10.0); } if( tempf>=but->min && tempf<=but->max) { value= ui_get_but_val(but); if(tempf != value ) { pos= 1; ui_set_but_val(but, tempf); ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops } } } } BIF_wait_for_statechange(); } /* click on the side arrows to increment/decrement, click inside * to edit the value directly */ if(pos==0) { /* plus 1 or minus 1 */ if( but->pointype!=FLO ) { if(sx < (but->x1 + (but->x2 - but->x1)/3 - 3)) { temp--; if( temp>=but->min && temp<=but->max) ui_set_but_val(but, (double)temp); } else if(sx > (but->x1 + (2*(but->x2 - but->x1)/3) + 3)) { temp++; if( temp>=but->min && temp<=but->max) ui_set_but_val(but, (double)temp); } else { if( uiActAsTextBut(but) ); else retval= 0; } } else { if(sx < (but->x1 + (but->x2 - but->x1)/3 - 3)) { tempf-= 0.01*but->a1; if (tempf < but->min) tempf = but->min; ui_set_but_val(but, tempf); } else if(sx > but->x1 + (2*((but->x2 - but->x1)/3) + 3)) { tempf+= 0.01*but->a1; if (tempf < but->min) tempf = but->min; ui_set_but_val(but, tempf); } else { if( uiActAsTextBut(but) ); else retval= 0; } } } } but->flag &= ~UI_SELECT; ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops uibut_do_func(but); return retval; } static int ui_do_but_TOG3(uiBut *but) { if( but->pointype==SHO ) { short *sp= (short *)but->poin; if( BTST(sp[1], but->bitnr)) { sp[1]= BCLR(sp[1], but->bitnr); sp[0]= BCLR(sp[0], but->bitnr); } else if( BTST(sp[0], but->bitnr)) { sp[1]= BSET(sp[1], but->bitnr); } else { sp[0]= BSET(sp[0], but->bitnr); } } else { if( BTST(*(but->poin+2), but->bitnr)) { *(but->poin+2)= BCLR(*(but->poin+2), but->bitnr); *(but->poin)= BCLR(*(but->poin), but->bitnr); } else if( BTST(*(but->poin), but->bitnr)) { *(but->poin+2)= BSET(*(but->poin+2), but->bitnr); } else { *(but->poin)= BSET(*(but->poin), but->bitnr); } } ui_is_but_sel(but); ui_draw_but(but); return but->retval; } static int ui_do_but_ICONROW(uiBut *but) { ListBase listb= {NULL, NULL}; uiBlock *block; int a; but->flag |= UI_SELECT; ui_draw_but(but); /* here we go! */ block= uiNewBlock(&listb, "menu", UI_EMBOSSP, UI_HELV, but->win); block->flag= UI_BLOCK_LOOP|UI_BLOCK_REDRAW|UI_BLOCK_NUMSELECT; block->themecol= TH_MENU_ITEM; for(a=(int)but->min; a<=(int)but->max; a++) { uiDefIconBut(block, BUTM|but->pointype, but->retval, but->icon+(a-but->min), 0, (short)(18*a), (short)(but->x2-but->x1-4), 18, but->poin, (float)a, 0.0, 0, 0, ""); } block->direction= UI_TOP; ui_positionblock(block, but); /* the block is made with but-win, but is handled in mainwin space... this is needs better implementation */ block->win= G.curscreen->mainwin; uiDoBlocks(&listb, 0); but->flag &= ~UI_SELECT; ui_check_but(but); ui_draw_but(but); return but->retval; } static int ui_do_but_ICONTEXTROW(uiBut *but) { uiBlock *block; ListBase listb={NULL, NULL}; int width, a, xmax, ypos; MenuData *md; but->flag |= UI_SELECT; ui_draw_but(but); block= uiNewBlock(&listb, "menu", UI_EMBOSSP, UI_HELV, but->win); block->flag= UI_BLOCK_LOOP|UI_BLOCK_REDRAW|UI_BLOCK_NUMSELECT; block->themecol= TH_MENU_ITEM; md= decompose_menu_string(but->str); /* size and location */ /* expand menu width to fit labels */ if(md->title) width= 2*strlen(md->title)+BIF_GetStringWidth(block->curfont, md->title, (U.transopts & USER_TR_MENUS)); else width= 0; for(a=0; anitems; a++) { xmax= BIF_GetStringWidth(block->curfont, md->items[a].str, (U.transopts & USER_TR_MENUS)); if(xmax>width) width= xmax; } width+= 30; if (width<50) width=50; ypos = 0; /* loop through the menu options and draw them out with icons & text labels */ for(a=0; anitems; a++) { /* add a space if there's a separator (%l) */ if (strcmp(md->items[a].str, "%l")==0) { ypos +=3; } else { uiDefIconTextBut(block, BUTM|but->pointype, but->retval, (short)((but->icon)+(md->items[a].retval-but->min)), md->items[a].str, 0, ypos,(short)width, 19, but->poin, (float) md->items[a].retval, 0.0, 0, 0, ""); ypos += 20; } } block->direction= UI_TOP; ui_positionblock(block, but); /* the block is made with but-win, but is handled in mainwin space... this is needs better implementation */ block->win= G.curscreen->mainwin; uiBoundsBlock(block, 3); uiDoBlocks(&listb, 0); menudata_free(md); but->flag &= ~UI_SELECT; ui_check_but(but); ui_draw_but(but); uibut_do_func(but); return but->retval; } static int ui_do_but_IDPOIN(uiBut *but) { char str[UI_MAX_DRAW_STR]; ID *id; id= *but->idpoin_idpp; if(id) strcpy(str, id->name+2); else str[0]= 0; but->type= TEX; but->poin= str; but->min= 0.0; but->max= 22.0; ui_do_but_TEX(but); but->poin= NULL; but->type= IDPOIN; but->idpoin_func(str, but->idpoin_idpp); ui_check_but(but); ui_draw_but(but); return but->retval; } static int ui_do_but_SLI(uiBut *but) { float f, fstart, tempf = 0.0, deler, value; int sx, h, temp, pos=0, lvalue, redraw; short mval[2], qual; float curmatrix[4][4]; value= ui_get_but_val(but); uiGetMouse(mywinget(), mval); sx= mval[0]; h= but->y2-but->y1; fstart= but->max-but->min; fstart= (value - but->min)/fstart; temp= 32767; if( but->type==NUMSLI) deler= ( (but->x2-but->x1)/2 - 5.0*but->aspect); else if( but->type==HSVSLI) deler= ( (but->x2-but->x1)/2 - 5.0*but->aspect); else deler= (but->x2-but->x1- 5.0*but->aspect); while (get_mbut() & L_MOUSE) { qual= get_qual(); uiGetMouse(mywinget(), mval); f= (float)(mval[0]-sx)/deler +fstart; if (qual & LR_SHIFTKEY) { f= (f-fstart)/10.0 + fstart; } CLAMP(f, 0.0, 1.0); tempf= but->min+f*(but->max-but->min); temp= floor(tempf+.5); if(qual & LR_CTRLKEY) { if(tempf==but->min || tempf==but->max); else if( but->pointype==FLO ) { if(but->max-but->min < 2.10) tempf= 0.1*floor(10*tempf); else if(but->max-but->min < 21.0) tempf= floor(tempf); else tempf= 10.0*floor(tempf/10.0); } else { temp= 10*(temp/10); tempf= temp; } } value= ui_get_but_val(but); lvalue= floor(value+0.5); if( but->pointype!=FLO ) redraw= (temp != lvalue); else redraw= (tempf != value); if (redraw) { pos= 1; ui_set_but_val(but, tempf); ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops if(but->a1) { /* color number */ uiBut *bt= but->prev; while(bt) { if(bt->a2 == but->a1) ui_draw_but(bt); bt= bt->prev; } bt= but->next; while(bt) { if(bt->a2 == but->a1) ui_draw_but(bt); bt= bt->next; } } /* save current window matrix (global UIwinmat) because button callback function MIGHT change it - which has until now occured through the Python API */ Mat4CpyMat4(curmatrix, UIwinmat); uibut_do_func(but); Mat4CpyMat4(UIwinmat, curmatrix); } else BIF_wait_for_statechange(); } if(temp!=32767 && pos==0) { /* plus 1 or minus 1 */ if( but->type==SLI) f= (float)(mval[0]-but->x1)/(but->x2-but->x1-h); else f= (float)(mval[0]- (but->x1+but->x2)/2)/( (but->x2-but->x1)/2 - h); f= but->min+f*(but->max-but->min); if( but->pointype!=FLO ) { if(f=but->min && temp<=but->max) ui_set_but_val(but, (float)temp); } else { if(f=but->min && tempf<=but->max) ui_set_but_val(but, tempf); } } ui_check_but(but); ui_draw_but(but); glFlush(); // flush display in subloops return but->retval; } static int ui_do_but_NUMSLI(uiBut *but) { short mval[2]; /* first define if it's a slider or textbut */ uiGetMouse(mywinget(), mval); if(mval[0]>= -6+(but->x1+but->x2)/2 ) { /* slider */ but->flag |= UI_SELECT; ui_draw_but(but); ui_do_but_SLI(but); but->flag &= ~UI_SELECT; } else { uiActAsTextBut(but); } while(get_mbut() & L_MOUSE) BIF_wait_for_statechange(); ui_draw_but(but); /* hsv patch */ if(but->type==HSVSLI) { if(but->str[0]=='H') { ui_draw_but(but->next); ui_draw_but(but->next->next); } else if(but->str[0]=='S') { ui_draw_but(but->next); ui_draw_but(but->prev); } else if(but->str[0]=='V') { ui_draw_but(but->prev); ui_draw_but(but->prev->prev); } } return but->retval; } static int ui_do_but_BLOCK(uiBut *but) { uiBlock *block; uiBut *bt; but->flag |= UI_SELECT; ui_draw_but(but); block= but->block_func(but->poin); block->xofs = -2; /* for proper alignment */ /* only used for automatic toolbox, so can set the shift flag */ if(but->flag & UI_MAKE_TOP) { block->direction= UI_TOP|UI_SHIFT_FLIPPED; uiBlockFlipOrder(block); } if(but->flag & UI_MAKE_DOWN) block->direction= UI_DOWN|UI_SHIFT_FLIPPED; if(but->flag & UI_MAKE_LEFT) block->direction |= UI_LEFT; if(but->flag & UI_MAKE_RIGHT) block->direction |= UI_RIGHT; ui_positionblock(block, but); block->flag |= UI_BLOCK_LOOP; /* blocks can come from a normal window, but we go to screenspace */ block->win= G.curscreen->mainwin; for(bt= block->buttons.first; bt; bt= bt->next) bt->win= block->win; bwin_getsinglematrix(block->win, block->winmat); /* postpone draw, this will cause a new window matrix, first finish all other buttons */ block->flag |= UI_BLOCK_REDRAW; but->flag &= ~UI_SELECT; uibut_do_func(but); return 0; } static int ui_do_but_BUTM(uiBut *but) { ui_set_but_val(but, but->min); UIafterfunc= but->butm_func; UIafterfunc_arg= but->butm_func_arg; UIafterval= but->a2; return but->retval; } static int ui_do_but_LABEL(uiBut *but) { uibut_do_func(but); return but->retval; } 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; } 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 BIF_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; } /* picker sizes S hsize, F full size, D spacer, B button/pallette height */ #define SPICK 110.0 #define FPICK 180.0 #define DPICK 6.0 #define BPICK 24.0 #define UI_PALETTE_TOT 16 /* note; in tot+1 the old color is stored */ static float palette[UI_PALETTE_TOT+1][3]= { {0.93, 0.83, 0.81}, {0.88, 0.89, 0.73}, {0.69, 0.81, 0.57}, {0.51, 0.76, 0.64}, {0.37, 0.56, 0.61}, {0.33, 0.29, 0.55}, {0.46, 0.21, 0.51}, {0.40, 0.12, 0.18}, {1.0, 1.0, 1.0}, {0.85, 0.85, 0.85}, {0.7, 0.7, 0.7}, {0.56, 0.56, 0.56}, {0.42, 0.42, 0.42}, {0.28, 0.28, 0.28}, {0.14, 0.14, 0.14}, {0.0, 0.0, 0.0} }; static void update_picker_buts(uiBlock *block, float *col) { uiBut *bt; float h, s, v; // this updates button strings, is hackish... but button pointers are on stack of caller function rgb_to_hsv(col[0], col[1], col[2], &h, &s, &v); for(bt= block->buttons.first; bt; bt= bt->next) { if(bt->str[1]==' ') { if(bt->str[0]=='R') { ui_set_but_val(bt, col[0]); ui_check_but(bt); } else if(bt->str[0]=='G') { ui_set_but_val(bt, col[1]); ui_check_but(bt); } else if(bt->str[0]=='B') { ui_set_but_val(bt, col[2]); ui_check_but(bt); } else if(bt->str[0]=='H') { ui_set_but_val(bt, h); ui_check_but(bt); } else if(bt->str[0]=='S') { ui_set_but_val(bt, s); ui_check_but(bt); } else if(bt->str[0]=='V') { ui_set_but_val(bt, v); ui_check_but(bt); } } } } /* bt1 is palette but, col1 is original color */ /* callback to copy from/to palette */ static void do_palette_cb(void *bt1, void *col1) { uiBut *but1= (uiBut *)bt1; uiBut *but; float *col= (float *)col1; float *fp; fp= (float *)but1->poin; if( (get_qual() & LR_CTRLKEY) ) { VECCOPY(fp, col); } else { VECCOPY(col, fp); } update_picker_buts(but1->block, col); for (but= but1->block->buttons.first; but; but= but->next) { ui_draw_but(but); } glFlush(); // flush display in subloops } /* bt1 is num but, col1 is pointer to original color */ /* callback to handle changes in num-buts in picker */ static void do_palette1_cb(void *bt1, void *col1) { uiBut *but1= (uiBut *)bt1; uiBut *but; float *col= (float *)col1; float *fp= NULL; if(but1->str[0]=='H') fp= (float *)but1->poin; else if(but1->str[0]=='S') fp= ((float *)but1->poin)-1; else if(but1->str[0]=='V') fp= ((float *)but1->poin)-2; if(fp) { hsv_to_rgb(fp[0], fp[1], fp[2], col, col+1, col+2); } update_picker_buts(but1->block, col); for (but= but1->block->buttons.first; but; but= but->next) { ui_draw_but(but); } glFlush(); // flush display in subloops } /* color picker, Gimp version. mode: 'f' = floating panel, 'p' = popup */ /* col = read/write to, hsv/old = memory for temporal use */ void uiBlockPickerButtons(uiBlock *block, float *col, float *hsv, float *old, char mode) { uiBut *bt; float h, offs; int a, retval=B_NOP; if(mode=='p') { // safety, put in beginning otherwise tooltips wont work retval= 0; // prevents event that closes popup } VECCOPY(old, col); // old color stored there, for palette_cb to work // the cube intersection bt= uiDefButF(block, HSVCUBE, retval, "", 0,DPICK+BPICK,FPICK,FPICK, col, 0.0, 0.0, 2, 0, ""); uiButSetFlag(bt, UI_NO_HILITE); bt= uiDefButF(block, HSVCUBE, retval, "", 0,0,FPICK,BPICK, col, 0.0, 0.0, 3, 0, ""); uiButSetFlag(bt, UI_NO_HILITE); // palette uiBlockSetEmboss(block, UI_EMBOSSP); bt=uiDefButF(block, COL, retval, "", FPICK+DPICK, 0, BPICK,BPICK, old, 0.0, 0.0, -1, 0, "Old color, click to restore"); uiButSetFunc(bt, do_palette_cb, bt, col); uiDefButF(block, COL, retval, "", FPICK+DPICK, BPICK+DPICK, BPICK,60-BPICK-DPICK, col, 0.0, 0.0, -1, 0, "Active color"); h= (DPICK+BPICK+FPICK-64)/(UI_PALETTE_TOT/2.0); uiBlockBeginAlign(block); for(a= -1+UI_PALETTE_TOT/2; a>=0; a--) { bt= uiDefButF(block, COL, retval, "", FPICK+DPICK, 65.0+(float)a*h, BPICK/2, h, palette[a+UI_PALETTE_TOT/2], 0.0, 0.0, -1, 0, "Click to choose, hold CTRL to store in palette"); uiButSetFunc(bt, do_palette_cb, bt, col); bt= uiDefButF(block, COL, retval, "", FPICK+DPICK+BPICK/2, 65.0+(float)a*h, BPICK/2, h, palette[a], 0.0, 0.0, -1, 0, "Click to choose, hold CTRL to store in palette"); uiButSetFunc(bt, do_palette_cb, bt, col); } uiBlockEndAlign(block); uiBlockSetEmboss(block, UI_EMBOSSX); // buttons rgb_to_hsv(col[0], col[1], col[2], hsv, hsv+1, hsv+2); offs= FPICK+2*DPICK+BPICK; uiBlockBeginAlign(block); bt= uiDefButF(block, NUM, retval, "R ", offs, 110, 80,20, col, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); bt= uiDefButF(block, NUM, retval, "G ", offs, 90, 80,20, col+1, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); bt= uiDefButF(block, NUM, retval, "B ", offs, 70, 80,20, col+2, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); uiBlockBeginAlign(block); bt= uiDefButF(block, NUM, retval, "H ", offs, 40, 80,20, hsv, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); bt= uiDefButF(block, NUM, retval, "S ", offs, 20, 80,20, hsv+1, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); bt= uiDefButF(block, NUM, retval, "V ", offs, 0, 80,20, hsv+2, 0.0, 1.0, 10, 2, ""); uiButSetFunc(bt, do_palette1_cb, bt, col); uiBlockEndAlign(block); } static int ui_do_but_COL(uiBut *but) { uiBlock *block; ListBase listb={NULL, NULL}; float hsv[3], old[3], *poin= NULL, colstore[3]; short event; // signal to prevent calling up color picker if(but->a1 == -1) { uibut_do_func(but); return but->retval; } // enable char button too, use temporal colstore for color if(but->pointype!=FLO) { if(but->pointype==CHA) { ui_get_but_vectorf(but, colstore); poin= colstore; } else return but->retval; } else poin= (float *)but->poin; block= uiNewBlock(&listb, "colorpicker", UI_EMBOSSX, UI_HELV, but->win); block->flag= UI_BLOCK_LOOP|UI_BLOCK_REDRAW; block->themecol= TH_BUT_NUM; uiBlockPickerButtons(block, poin, hsv, old, 'p'); /* and lets go */ block->direction= UI_TOP; ui_positionblock(block, but); block->win= G.curscreen->mainwin; event= uiDoBlocks(&listb, 0); if(but->pointype==CHA) ui_set_but_vectorf(but, colstore); return but->retval; } static int ui_do_but_HSVCUBE(uiBut *but) { uiBut *bt; float x, y, col[3], h,s,v; short mval[2], mvalo[2]; mvalo[0]= mvalo[1]= -32000; while (get_mbut() & L_MOUSE) { uiGetMouse(mywinget(), mval); if(mval[0]!=mvalo[0] || mval[1]!=mvalo[1]) { mvalo[0]= mval[0]; mvalo[1]= mval[1]; /* relative position within box */ x= ((float)mval[0]-but->x1)/(but->x2-but->x1); y= ((float)mval[1]-but->y1)/(but->y2-but->y1); /* we're hacking values now to prevent rgb_to_hsv working wrong */ /* (ton) doesnt work yet... */ CLAMP(x, 0.0002, 0.9998); CLAMP(y, 0.0002, 0.9998); /* assign position to color */ ui_get_but_vectorf(but, col); /* another attempt to prevent hsv from hanging */ CLAMP(col[0], 0.0002, 0.9998); CLAMP(col[1], 0.0002, 0.9998); CLAMP(col[2], 0.0002, 0.9998); rgb_to_hsv(col[0], col[1], col[2], &h, &s, &v); if(v==0.0) v= 0.0002; if(s==0.0) s= 0.0002; if(but->a1==0) hsv_to_rgb(x, s, y, col, col+1, col+2); else if(but->a1==1) hsv_to_rgb(x, y, v, col, col+1, col+2); else if(but->a1==2) hsv_to_rgb(h, y, x, col, col+1, col+2); else hsv_to_rgb(x, s, v, col, col+1, col+2); ui_set_but_vectorf(but, col); // update button values and strings update_picker_buts(but->block, col); /* we redraw the entire block */ for (bt= but->block->buttons.first; bt; bt= bt->next) { ui_draw_but(bt); } glFlush(); // flush display in subloops } else BIF_wait_for_statechange(); } return but->retval; } /* ************************************************ */ void uiSetButLock(int val, char *lockstr) { UIlock |= val; if (val) UIlockstr= lockstr; } void uiClearButLock() { UIlock= 0; UIlockstr= NULL; } /* ********************** NEXT/PREV for arrowkeys etc ************** */ static uiBut *ui_but_prev(uiBut *but) { while(but->prev) { but= but->prev; if(but->type!=LABEL && but->type!=SEPR) return but; } return NULL; } static uiBut *ui_but_next(uiBut *but) { while(but->next) { but= but->next; if(but->type!=LABEL && but->type!=SEPR) return but; } return NULL; } static uiBut *ui_but_first(uiBlock *block) { uiBut *but; but= block->buttons.first; while(but) { if(but->type!=LABEL && but->type!=SEPR) return but; but= but->next; } return NULL; } static uiBut *ui_but_last(uiBlock *block) { uiBut *but; but= block->buttons.last; while(but) { if(but->type!=LABEL && but->type!=SEPR) return but; but= but->prev; } return NULL; } /* *************************************************************** */ static void setup_file(uiBlock *block) { uiBut *but; FILE *fp; fp= fopen("butsetup","w"); if(fp==NULL); else { but= block->buttons.first; while(but) { // if(but->rt[3]==1) { 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); glFlush(); didit= 1; but->rt[3]= 1; } /* idle for this poor code */ else PIL_sleep_ms(30); } if(didit) setup_file(block); } /* is called when LEFTMOUSE is pressed or released * return: butval or zero */ static int ui_do_button(uiBlock *block, uiBut *but, uiEvent *uevent) { int retval= 0; if(but->lock) { if (but->lockstr) { error("%s", but->lockstr); return 0; } } else { if( but->pointype ) { /* there's a pointer needed */ if(but->poin==0 ) { printf("DoButton pointer error: %s\n",but->str); return 0; } } } if(G.rt==1 && (uevent->qual & LR_CTRLKEY)) { edit_but(block, but, uevent); return 0; } block->flag |= UI_BLOCK_BUSY; switch(but->type) { case BUT: if(uevent->val) retval= ui_do_but_BUT(but); break; case KEYEVT: if(uevent->val) retval= ui_do_but_KEYEVT(but); break; case TOG: case TOGR: case ICONTOG: case TOGN: if(uevent->val) { retval= ui_do_but_TOG(block, but); } break; case ROW: if(uevent->val) retval= ui_do_but_ROW(block, but); break; case SCROLL: /* DrawBut(b, 1); */ /* do_scrollbut(b); */ /* DrawBut(b,0); */ break; case NUM: if(uevent->val) retval= ui_do_but_NUM(but); break; case SLI: case NUMSLI: case HSVSLI: if(uevent->val) retval= ui_do_but_NUMSLI(but); break; case LABEL: if(uevent->val) retval= ui_do_but_LABEL(but); break; case TOG3: if(uevent->val) retval= ui_do_but_TOG3(but); break; case TEX: if(uevent->val) retval= ui_do_but_TEX(but); break; case MENU: if(uevent->val) retval= ui_do_but_MENU(but); break; case ICONROW: if(uevent->val) retval= ui_do_but_ICONROW(but); break; case ICONTEXTROW: if(uevent->val) retval= ui_do_but_ICONTEXTROW(but); break; case IDPOIN: if(uevent->val) retval= ui_do_but_IDPOIN(but); break; case BLOCK: if(uevent->val) { retval= ui_do_but_BLOCK(but); if(block->auto_open==0) block->auto_open= 1; } break; case BUTM: retval= ui_do_but_BUTM(but); break; case LINK: case INLINK: retval= ui_do_but_LINK(block, but); break; case COL: if(uevent->val) retval= ui_do_but_COL(but); break; case HSVCUBE: retval= ui_do_but_HSVCUBE(but); break; } block->flag &= ~UI_BLOCK_BUSY; return retval; } 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) { /* 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; } } } /* only to be used to prevent an 'outside' event when using nested pulldowns */ /* four checks: - while mouse moves in good x direction - while mouse motion x is bigger than y motion - while distance to center block diminishes - only for 1 second return 0: check outside */ static int ui_mouse_motion_towards_block(uiBlock *block, uiEvent *uevent) { short mvalo[2], dx, dy, domx, domy, x1, y1; int disto, dist, counter=0; if((block->direction & UI_TOP) || (block->direction & UI_DOWN)) return 0; if(uevent->event!= MOUSEX && uevent->event!= MOUSEY) return 0; /* calculate dominant direction */ domx= ( -uevent->mval[0] + (block->maxx+block->minx)/2 ); domy= ( -uevent->mval[1] + (block->maxy+block->miny)/2 ); /* we need some accuracy */ if( abs(domx)<4 ) return 0; /* calculte old dist */ disto= domx*domx + domy*domy; uiGetMouse(mywinget(), mvalo); while(TRUE) { uiGetMouse(mywinget(), uevent->mval); /* check inside, if so return */ if( block->minx <= uevent->mval[0] && block->maxx >= uevent->mval[0] ) { if( block->miny <= uevent->mval[1] && block->maxy >= uevent->mval[1] ) { return 1; } } /* check direction */ dx= uevent->mval[0] - mvalo[0]; dy= uevent->mval[1] - mvalo[1]; if( abs(dx)+abs(dy)>4 ) { // threshold if( abs(dy) > abs(dx) ) { //printf("left because y>x direction\n"); return 0; } if( dx>0 && domx>0); else if(dx<0 && domx<0); else { //printf("left because dominant direction\n"); return 0; } } /* check dist */ x1= ( -uevent->mval[0] + (block->maxx+block->minx)/2 ); y1= ( -uevent->mval[1] + (block->maxy+block->miny)/2 ); dist= x1*x1 + y1*y1; if(dist > disto) { //printf("left because distance\n"); return 0; } else disto= dist; /* idle for this poor code */ PIL_sleep_ms(10); counter++; if(counter > 100) { // printf("left because of timer (1 sec)\n"); return 0; } } return 0; } static void ui_set_ftf_font(uiBlock *block) { #ifdef INTERNATIONAL if(block->aspect<1.15) { FTF_SetFontSize('l'); } else if(block->aspect<1.59) { FTF_SetFontSize('m'); } else { FTF_SetFontSize('s'); } #endif } /* return: * UI_NOTHING pass event to other ui's * UI_CONT don't pass event to other ui's * UI_RETURN something happened, return, swallow event */ static int ui_do_block(uiBlock *block, uiEvent *uevent) { uiBut *but, *bt; int butevent, event, retval=UI_NOTHING, count, act=0; int inside= 0, active=0; if(block->win != mywinget()) return UI_NOTHING; /* filter some unwanted events */ /* btw: we allow event==0 for first time in menus, draws the hilited item */ if(uevent==0 || uevent->event==LEFTSHIFTKEY || uevent->event==RIGHTSHIFTKEY) return UI_NOTHING; if(block->flag & UI_BLOCK_ENTER_OK) { if(uevent->event == RETKEY && uevent->val) { // printf("qual: %d %d %d\n", uevent->qual, get_qual(), G.qual); if ((G.qual & LR_SHIFTKEY) == 0) { return UI_RETURN_OK; } } } ui_set_ftf_font(block); // sets just a pointer in ftf lib... the button dont have ftf handles // added this for panels in windows with buttons... // maybe speed optimize should require test if((block->flag & UI_BLOCK_LOOP)==0) { glMatrixMode(GL_PROJECTION); bwin_load_winmatrix(block->win, block->winmat); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } Mat4CpyMat4(UIwinmat, block->winmat); uiPanelPush(block); // push matrix; no return without pop! uiGetMouse(mywinget(), uevent->mval); /* transformed mouseco */ /* check boundbox and panel events */ if( block->minx <= uevent->mval[0] && block->maxx >= uevent->mval[0] ) { // inside block if( block->miny <= uevent->mval[1] && block->maxy >= uevent->mval[1] ) inside= 1; if(block->panel && block->panel->paneltab==NULL) { /* clicked at panel header? */ if( block->panel->flag & PNL_CLOSEDX) { if(block->minx <= uevent->mval[0] && block->minx+PNL_HEADER >= uevent->mval[0]) inside= 2; } else if( (block->maxy <= uevent->mval[1]) && (block->maxy+PNL_HEADER >= uevent->mval[1]) ) inside= 2; if(inside) { // this stuff should move to do_panel if(uevent->event==LEFTMOUSE) { if(inside==2) { uiPanelPop(block); // pop matrix; no return without pop! ui_do_panel(block, uevent); return UI_EXIT_LOOP; // exit loops because of moving panels } } else if(uevent->event==ESCKEY) { if(block->handler) { rem_blockhandler(curarea, block->handler); addqueue(curarea->win, REDRAW, 1); } } else if(uevent->event==PADPLUSKEY || uevent->event==PADMINUS) { SpaceLink *sl= curarea->spacedata.first; if(curarea->spacetype!=SPACE_BUTS) { if(uevent->event==PADPLUSKEY) sl->blockscale+= 0.1; else sl->blockscale-= 0.1; CLAMP(sl->blockscale, 0.6, 1.0); addqueue(block->winq, REDRAW, 1); retval= UI_CONT; } } } } } switch(uevent->event) { case LEFTARROWKEY: // later on implement opening/closing sublevels of pupmenus case RIGHTARROWKEY: break; case RETKEY: // prevent treating this as mousemove. for example when you enter at popup break; case PAD8: case PAD2: case UPARROWKEY: case DOWNARROWKEY: if(inside || (block->flag & UI_BLOCK_LOOP)) { /* arrowkeys: only handle for block_loop blocks */ event= 0; if(block->flag & UI_BLOCK_LOOP) { event= uevent->event; if(event==PAD8) event= UPARROWKEY; if(event==PAD2) event= DOWNARROWKEY; } else { if(uevent->event==PAD8) event= UPARROWKEY; if(uevent->event==PAD2) event= DOWNARROWKEY; } if(event && uevent->val) { but= block->buttons.first; while(but) { but->flag &= ~UI_MOUSE_OVER; if(but->flag & UI_ACTIVE) { but->flag &= ~UI_ACTIVE; ui_draw_but(but); if(event==UPARROWKEY) { if(block->direction & UI_TOP) bt= ui_but_next(but); else bt= ui_but_prev(but); } else { if(block->direction & UI_TOP) bt= ui_but_prev(but); else bt= ui_but_next(but); } if(bt) { bt->flag |= UI_ACTIVE; ui_draw_but(bt); break; } } but= but->next; } /* nothing done */ if(but==NULL) { if(event==UPARROWKEY) { if(block->direction & UI_TOP) but= ui_but_first(block); else but= ui_but_last(block); } else { if(block->direction & UI_TOP) but= ui_but_last(block); else but= ui_but_first(block); } if(but) { but->flag |= UI_ACTIVE; ui_draw_but(but); } } retval= UI_CONT; } } break; case ONEKEY: act= 1; case TWOKEY: if(act==0) act= 2; case THREEKEY: if(act==0) act= 3; case FOURKEY: if(act==0) act= 4; case FIVEKEY: if(act==0) act= 5; case SIXKEY: if(act==0) act= 6; case SEVENKEY: if(act==0) act= 7; case EIGHTKEY: if(act==0) act= 8; case NINEKEY: if(act==0) act= 9; case ZEROKEY: if(act==0) act= 10; if( block->flag & UI_BLOCK_NUMSELECT ) { if(get_qual() & LR_ALTKEY) act+= 10; but= block->buttons.first; count= 0; while(but) { int doit= 0; if(but->type!=LABEL && but->type!=SEPR) count++; /* exception for menus like layer buts, with button aligning they're not drawn in order */ if(but->type==TOGR) { if(but->bitnr==act-1) doit= 1; } else if(count==act) doit=1; if(doit) { but->flag |= UI_ACTIVE; if(uevent->val==1) ui_draw_but(but); else if(block->flag & UI_BLOCK_RET_1) { /* to make UI_BLOCK_RET_1 working */ uevent->event= RETKEY; uevent->val= 1; //addqueue(block->winq, RIGHTARROWKEY, 1); (why! (ton)) } else { uevent->event= LEFTMOUSE; /* to make sure the button is handled further on */ uevent->val= 1; } } else if(but->flag & UI_ACTIVE) { but->flag &= ~UI_ACTIVE; ui_draw_but(but); } but= but->next; } } break; default: but= block->buttons.first; while(but) { but->flag &= ~UI_MOUSE_OVER; /* check boundbox */ if (uibut_contains_pt(but, uevent->mval)) { but->flag |= UI_MOUSE_OVER; UIbuttip= but; } /* hilite case 1 */ if(but->flag & UI_MOUSE_OVER) { if( (but->flag & UI_ACTIVE)==0) { but->flag |= UI_ACTIVE; if(but->type != LABEL && (but->flag & UI_NO_HILITE)==0) ui_draw_but(but); } } /* hilite case 2 */ if(but->flag & UI_ACTIVE) { if( (but->flag & UI_MOUSE_OVER)==0) { /* we dont clear active flag until mouse move, for Menu buttons to remain showing active item when opened */ if (uevent->event==MOUSEY) { but->flag &= ~UI_ACTIVE; if(but->type != LABEL && (but->flag & UI_NO_HILITE)==0) ui_draw_but(but); } } else if(but->type==BLOCK || but->type==MENU) { // automatic opens block button (pulldown) int time; if(uevent->event!=LEFTMOUSE ) { if(block->auto_open==2) time= 1; // test for toolbox else if(block->auto_open) time= 5*U.menuthreshold2; else if(U.uiflag & USER_MENUOPENAUTO) time= 5*U.menuthreshold1; else time= -1; for (; time>0; time--) { if (qtest()) break; else PIL_sleep_ms(20); } if(time==0) { uevent->val= 1; // otherwise buttons dont react ui_do_button(block, but, uevent); } } } if(but->flag & UI_ACTIVE) active= 1; } but= but->next; } /* if there are no active buttons... otherwise clear lines */ if(active) ui_do_active_linklines(block, 0); else ui_do_active_linklines(block, uevent->mval); } /* middlemouse exception, not for regular blocks */ if( (block->flag & UI_BLOCK_LOOP) && uevent->event==MIDDLEMOUSE) uevent->event= LEFTMOUSE; /* the final dobutton */ but= block->buttons.first; while(but) { if(but->flag & UI_ACTIVE) { /* UI_BLOCK_RET_1: not return when val==0 */ if(uevent->val || (block->flag & UI_BLOCK_RET_1)==0) { if ELEM3(uevent->event, LEFTMOUSE, PADENTER, RETKEY) { /* when mouse outside, don't do button */ if(inside || uevent->event!=LEFTMOUSE) { butevent= ui_do_button(block, but, uevent); if(butevent) addqueue(block->winq, UI_BUT_EVENT, (short)butevent); /* i doubt about the next line! */ /* if(but->func) mywinset(block->win); */ if( (block->flag & UI_BLOCK_LOOP) && but->type==BLOCK); else if(/*but->func ||*/ butevent) retval= UI_RETURN_OK; } } } } but= but->next; } uiPanelPop(block); // pop matrix; no return without pop! /* the linkines... why not make buttons from it? Speed? Memory? */ if(uevent->val && (uevent->event==XKEY || uevent->event==DELKEY)) ui_delete_active_linkline(block); if(block->flag & UI_BLOCK_LOOP) { if(inside==0 && uevent->val==1) { if ELEM3(uevent->event, LEFTMOUSE, MIDDLEMOUSE, RIGHTMOUSE) { if(BLI_in_rctf(&block->parentrct, (float)uevent->mval[0], (float)uevent->mval[1])); else return UI_RETURN_OUT; } } if(uevent->event==ESCKEY && uevent->val==1) return UI_RETURN_CANCEL; if((uevent->event==RETKEY || uevent->event==PADENTER) && uevent->val==1) return UI_RETURN_OK; /* check outside */ if(inside==0) { /* strict check, and include the parent rect */ if( BLI_in_rctf(&block->parentrct, (float)uevent->mval[0], (float)uevent->mval[1])); else if( ui_mouse_motion_towards_block(block, uevent)); else if( BLI_in_rctf(&block->safety, (float)uevent->mval[0], (float)uevent->mval[1])); else return UI_RETURN_OUT; } } return retval; } static uiSaveUnder *ui_draw_but_tip(uiBut *but) { uiSaveUnder *su; float x1, x2, y1, y2; #ifdef INTERNATIONAL if(G.ui_international == TRUE) { float llx,lly,llz,urx,ury,urz; //for FTF_GetBoundingBox() if(U.transopts & USER_TR_TOOLTIPS) { FTF_GetBoundingBox(but->tip, &llx,&lly,&llz,&urx,&ury,&urz, FTF_USE_GETTEXT | FTF_INPUT_UTF8); x1= (but->x1+but->x2)/2; x2= 10+x1+ but->aspect*FTF_GetStringWidth(but->tip, FTF_USE_GETTEXT | FTF_INPUT_UTF8); //BMF_GetStringWidth(but->font, but->tip); y1= but->y1-(ury+FTF_GetSize())-12; y2= but->y1-12; } else { FTF_GetBoundingBox(but->tip, &llx,&lly,&llz,&urx,&ury,&urz, FTF_NO_TRANSCONV | FTF_INPUT_UTF8); x1= (but->x1+but->x2)/2; x2= 10+x1+ but->aspect*FTF_GetStringWidth(but->tip, FTF_NO_TRANSCONV | FTF_INPUT_UTF8); //BMF_GetStringWidth(but->font, but->tip); y1= but->y1-(ury+FTF_GetSize())-12; y2= but->y1-12; } } else { x1= (but->x1+but->x2)/2; x2= 10+x1+ but->aspect*BMF_GetStringWidth(but->font, but->tip); y1= but->y1-30; y2= but->y1-12; } #else x1= (but->x1+but->x2)/2; x2= 10+x1+ but->aspect*BMF_GetStringWidth(but->font, but->tip); y1= but->y1-30; y2= but->y1-12; #endif /* for pulldown menus it doesnt work */ if(mywinget()==G.curscreen->mainwin); else { ui_graphics_to_window(mywinget(), &x1, &y1); ui_graphics_to_window(mywinget(), &x2, &y2); } if(x2 > G.curscreen->sizex) { x1 -= x2-G.curscreen->sizex; x2= G.curscreen->sizex; } if(y1 < 0) { y1 += 36; y2 += 36; } // adjust tooltip heights if(mywinget()==G.curscreen->mainwin) y2 -= G.ui_international ? 4:1; //tip is from pulldownmenu else if(curarea->win != mywinget()) y2 -= G.ui_international ? 5:1; //tip is from a windowheader // else y2 += 1; //tip is from button area su= ui_bgnpupdraw((int)(x1-1), (int)(y1-2), (int)(x2+4), (int)(y2+4), 0); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glColor4ub(0, 0, 0, 20); glBegin(GL_POLYGON); gl_round_box(x1+3, y1-1, x2+1, y2-2, 2.0); gl_round_box(x1+3, y1-2, x2+2, y2-2, 3.0); glColor4ub(0, 0, 0, 8); gl_round_box(x1+3, y1-3, x2+3, y2-3, 4.0); gl_round_box(x1+3, y1-4, x2+4, y2-3, 5.0); glEnd(); glDisable(GL_BLEND); glColor3ub(0xFF, 0xFF, 0xDD); glRectf(x1, y1, x2, y2); glColor3ub(0,0,0); glRasterPos2f( x1+3, y1+5.0/but->aspect); BIF_DrawString(but->font, but->tip, (U.transopts & USER_TR_TOOLTIPS)); glFlush(); /* to show it in the frontbuffer */ return su; } /* inside this function no global UIbuttip... qread is not safe */ static void ui_do_but_tip(uiBut *buttip) { uiSaveUnder *su; int time; if (buttip && buttip->tip && buttip->tip[0]) { /* Pause for a moment to see if we * should really display the tip * or if the user will keep moving * the pointer. */ for (time= 0; time<25; time++) { if (anyqtest()) return; else PIL_sleep_ms(20); } /* Display the tip, and keep it displayed * as long as the mouse remains on top * of the button that owns it. */ uiPanelPush(buttip->block); // panel matrix su= ui_draw_but_tip(buttip); while (1) { char ascii; short val; unsigned short evt= extern_qread_ext(&val, &ascii); if (evt==MOUSEX || evt==MOUSEY) { short mouse[2]; uiGetMouse(su->oldwin, mouse); if (!uibut_contains_pt(buttip, mouse)) break; } else { mainqpushback(evt, val, ascii); break; } } ui_endpupdraw(su); uiPanelPop(buttip->block); // panel matrix /* still the evil global.... */ UIbuttip= NULL; } } /* returns UI_NOTHING, if nothing happened */ int uiDoBlocks(ListBase *lb, int event) { /* return when: firstblock != BLOCK_LOOP * * 'cont' is used to make sure you can press another button while a looping menu * is active. otherwise you have to press twice... */ uiBlock *block, *first; uiEvent uevent; int retval= UI_NOTHING, cont= 1; if(lb->first==0) return UI_NOTHING; /* for every pixel both x and y events are generated, overloads the system! */ if(event==MOUSEX) return UI_NOTHING; UIbuttip= NULL; UIafterfunc= NULL; /* to prevent infinite loops, this shouldnt be a global! */ uevent.qual= G.qual; uevent.event= event; uevent.val= 1; /* this is a caching mechanism, to prevent too many calls to glFrontBuffer and glFlush, which slows down interface */ block= lb->first; while(block) { block->frontbuf= UI_NEED_DRAW_FRONT; // signal block= block->next; } /* main loop, needed when you click outside a looping block (menu) then it uses that event to immediately evaluate the other uiBlocks again. */ while(cont) { /* first loop, for the normal blocks */ block= lb->first; while(block) { /* for pupmenus, the bgnpupdraw sets (and later restores) the active window. Then mousecoords get transformed OK. It looks double... but a call to ui_do_block otherwise doesnt get handled properly */ if(block->flag & UI_BLOCK_REDRAW) { if( block->flag & UI_BLOCK_LOOP) { block->saveunder= ui_bgnpupdraw((int)block->minx-1, (int)block->miny-6, (int)block->maxx+6, (int)block->maxy+1, 1); block->frontbuf= UI_HAS_DRAW_FRONT; } uiDrawBlock(block); block->flag &= ~UI_BLOCK_REDRAW; } retval= ui_do_block(block, &uevent); if(retval==UI_EXIT_LOOP) break; /* now a new block could be created for menus, this is inserted in the beginning of a list */ /* is there a glfinish cached? */ if(block->frontbuf == UI_HAS_DRAW_FRONT) { glFlush(); glDrawBuffer(GL_BACK); block->frontbuf= UI_NEED_DRAW_FRONT; } /* to make sure the matrix of the panel works for menus too */ if(retval==UI_CONT || (retval & UI_RETURN)) break; first= lb->first; if(first->flag & UI_BLOCK_LOOP) break; block= block->next; } /* second loop, for menus (looping blocks). works for sub->menus too */ block= lb->first; if(block==NULL || (block->flag & UI_BLOCK_LOOP)==0) cont= 0; while( (block= lb->first) && (block->flag & UI_BLOCK_LOOP)) { if(block->auto_open==0) block->auto_open= 1; /* this here, for menu buts */ if(block->flag & UI_BLOCK_REDRAW) { if( block->flag & UI_BLOCK_LOOP) { block->saveunder= ui_bgnpupdraw((int)block->minx-1, (int)block->miny-6, (int)block->maxx+6, (int)block->maxy+1, 1); block->frontbuf= UI_HAS_DRAW_FRONT; } uiDrawBlock(block); block->flag &= ~UI_BLOCK_REDRAW; } /* need to reveil drawing? (not in end of loop, because of free block */ if(block->frontbuf == UI_HAS_DRAW_FRONT) { glFlush(); block->frontbuf= UI_NEED_DRAW_FRONT; } uevent.event= extern_qread(&uevent.val); if(uevent.event) { retval= ui_do_block(block, &uevent); if(retval & UI_RETURN) { /* free this block */ ui_endpupdraw(block->saveunder); BLI_remlink(lb, block); uiFreeBlock(block); } if(retval & (UI_RETURN_OK|UI_RETURN_CANCEL)) { /* free other menus */ while( (block= lb->first) && (block->flag & UI_BLOCK_LOOP)) { ui_endpupdraw(block->saveunder); BLI_remlink(lb, block); uiFreeBlock(block); } } } /* tooltip */ if(retval==UI_NOTHING && (uevent.event==MOUSEX || uevent.event==MOUSEY)) { if(U.flag & USER_TOOLTIPS) ui_do_but_tip(UIbuttip); } } /* else it does the first part of this loop again, maybe another menu needs to be opened */ if(retval==UI_CONT || (retval & UI_RETURN_OK)) cont= 0; } /* cleanup frontbuffer & flags */ block= lb->first; while(block) { if(block->frontbuf==UI_HAS_DRAW_FRONT) glFlush(); block->frontbuf= 0; block= block->next; } /* afterfunc is used for fileloading too, so after this call, the blocks pointers are invalid */ if(retval & UI_RETURN_OK) { if(UIafterfunc) UIafterfunc(UIafterfunc_arg, UIafterval); UIafterfunc= NULL; } /* tooltip */ if(retval==UI_NOTHING && (uevent.event==MOUSEX || uevent.event==MOUSEY)) { if(U.flag & USER_TOOLTIPS) ui_do_but_tip(UIbuttip); } /* doesnt harm :-) */ glDrawBuffer(GL_BACK); return retval; } /* ************** DATA *************** */ /* for buttons pointing to color for example */ void ui_get_but_vectorf(uiBut *but, float *vec) { void *poin; poin= but->poin; if( but->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( but->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; poin= but->poin; if( 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); } } double ui_get_but_val(uiBut *but) { void *poin; double value = 0.0; poin= but->poin; if(but->type== HSVSLI) { float h, s, v, *fp= (float *) 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 *)poin; } else if( but->pointype == SHO ) { value= *(short *)poin; } else if( but->pointype == INT ) { value= *(int *)poin; } else if( but->pointype == FLO ) { value= *(float *)poin; } return value; } static void ui_set_but_val(uiBut *but, double value) { void *poin; if(but->pointype==0) return; poin= but->poin; /* value is a hsv value: convert to rgb */ if( but->type==HSVSLI ) { float h, s, v, *fp= (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 if( but->pointype==CHA ) *((char *)poin)= (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); *((short *)poin)= (short) gcckludge; } else if( but->pointype==INT ) *((int *)poin)= (int)floor(value+0.5); else if( but->pointype==FLO ) *((float *)poin)= value; /* update select flag */ ui_is_but_sel(but); } void uiSetCurFont(uiBlock *block, int index) { ui_set_ftf_font(block); 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); } 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; } static void ui_free_link(uiLink *link) { if(link) { BLI_freelistN(&link->lines); MEM_freeN(link); } } static void ui_free_but(uiBut *but) { if(but->str && but->str != but->strdata) MEM_freeN(but->str); ui_free_link(but->link); MEM_freeN(but); } void uiFreeBlock(uiBlock *block) { uiBut *but; if(block->flag & UI_BLOCK_BUSY) printf("attempt to free busy buttonblock: %p\n", block); while( (but= block->buttons.first) ) { BLI_remlink(&block->buttons, but); ui_free_but(but); } if(block->panel) block->panel->active= 0; MEM_freeN(block); UIbuttip= NULL; } void uiFreeBlocks(ListBase *lb) { uiBlock *block; while( (block= lb->first) ) { BLI_remlink(lb, block); uiFreeBlock(block); } } void uiFreeBlocksWin(ListBase *lb, int win) { uiBlock *block, *blockn; block= lb->first; while(block) { blockn= block->next; if(block->win==win) { BLI_remlink(lb, block); uiFreeBlock(block); } block= blockn; } } uiBlock *uiNewBlock(ListBase *lb, char *name, short dt, short font, short win) { uiBlock *block; /* each listbase only has one block with this name */ if(lb) { for (block= lb->first; block; block= block->next) if (BLI_streq(block->name, name)) break; if (block) { BLI_remlink(lb, block); uiFreeBlock(block); } } block= MEM_callocN(sizeof(uiBlock), "uiBlock"); if(lb) BLI_addhead(lb, block); /* at the beginning of the list! for dynamical menus/blocks */ strcpy(block->name, name); /* 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(); block->dt= dt; block->themecol= TH_AUTO; /* aspect */ bwin_getsinglematrix(win, block->winmat); if (win==G.curscreen->mainwin) { block->aspect= 1.0; block->auto_open= 2; } else { int getsizex, getsizey; bwin_getsize(win, &getsizex, &getsizey); block->aspect= 2.0/( (getsizex)*block->winmat[0][0]); } uiSetCurFont(block, font); return block; } uiBlock *uiGetBlock(char *name, ScrArea *sa) { uiBlock *block= sa->uiblocks.first; while(block) { if( strcmp(name, block->name)==0 ) return block; block= block->next; } return NULL; } /* used for making screenshots for menus, called in screendump.c */ int uiIsMenu(int *x, int *y, int *sizex, int *sizey) { uiBlock *block= curarea->uiblocks.first; int minx, miny, maxx, maxy; minx= 1<<30; miny= 1<<30; maxx= 0; maxy= 0; while(block) { if(block->flag & UI_BLOCK_LOOP) { if(block->minx < minx) minx= (int)block->minx; if(block->miny < miny) miny= (int)block->miny; if(block->maxx > maxx) maxx= (int)block->maxx; if(block->maxy > maxy) maxy= (int)block->maxy; } block= block->next; } printf("%d %d %d %d\n", minx, miny, maxx, maxy); if(maxx!=0 && maxy!=0) { *x= minx-10<0?0:minx; *y= miny-10<0?0:miny; *sizex= maxx-minx+10; *sizey= maxy-miny+10; return 1; } return 0; } void ui_check_but(uiBut *but) { /* if something changed in the button */ ID *id; double value; float okwidth; short pos; ui_is_but_sel(but); /* 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: value= ui_get_but_val(but); if( but->pointype==FLO ) { 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( but->pointype==FLO && but->poin) { 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: strcpy(but->drawstr, but->str); strcat(but->drawstr, but->poin); break; case KEYEVT: strcpy(but->drawstr, but->str); if (but->flag & UI_SELECT) { strcat(but->drawstr, "Press a key"); } else { strcat(but->drawstr, key_event_to_string((short) ui_get_but_val(but))); } break; default: strcpy(but->drawstr, but->str); } if(but->drawstr[0]) { but->strwidth= but->aspect*BIF_GetStringWidth(but->font, but->drawstr, (U.transopts & USER_TR_BUTTONS)); // here should be check for less space for icon offsets... if(but->type==MENU) okwidth -= 20; } else but->strwidth= 0; /* automatic width */ if(but->x2==0.0) { but->x2= (but->x1+but->strwidth+6); } if(but->strwidth==0) but->drawstr[0]= 0; else if(but->type==BUTM); // clip string else { /* calc but->ofs, to draw the string shorter if too long */ but->ofs= 0; while(but->strwidth > (int)okwidth ) { but->ofs++; if(but->drawstr[but->ofs]) but->strwidth= but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS)); else but->strwidth= 0; /* textbut exception */ if(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; } } if(but->strwidth < 10) break; } /* fix for buttons that better not have text cut off to the right */ if(but->ofs) { if ELEM(but->type, NUM, TEX); // only these cut off left else { but->drawstr[ strlen(but->drawstr)-but->ofs ]= 0; but->ofs= 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) value= but->min; if(value > but->max) value= but->max; ui_set_but_val(but, value); break; case ICONTOG: 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; } } 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: return TH_BUT_SETTING; case SLI: case NUM: case NUMSLI: case HSVSLI: return TH_BUT_NUM; case TEX: return TH_BUT_TEXTFIELD; case BLOCK: case MENU: case BUTM: // (weak!) detect if it is a blockloop if(UIbuttip) return TH_MENU_ITEM; return TH_BUT_POPUP; 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; if ( !((BIF_GetThemeValue(TH_BUT_DRAWTYPE) == 1) || (BIF_GetThemeValue(TH_BUT_DRAWTYPE) == 2))) 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 */ 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 */ flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT; } 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 } 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 } 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==0) { /* if pointer is zero, button is removed and not drawn */ BIF_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; 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= UIlock; but->lockstr= UIlockstr; but->aspect= block->aspect; but->win= block->win; but->block= block; // pointer back, used for frontbuffer status if(block->themecol==TH_AUTO) but->themecol= ui_auto_themecol(but); else but->themecol= block->themecol; if (but->type==BUTM) { but->butm_func= block->butm_func; but->butm_func_arg= block->butm_func_arg; } else { 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(but->type==NUM) { /* add a space to name */ slen= strlen(but->str); if(slen>0 && slenstr[slen-1]!=' ') { but->str[slen]= ' '; but->str[slen+1]= 0; } } } if ELEM8(but->type, HSVSLI , NUMSLI, MENU, TEX, LABEL, IDPOIN, BLOCK, BUTM) { but->flag |= UI_TEXT_LEFT; } but->flag |= (block->flag & UI_BUT_ALIGN); 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<>=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; } } 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); } /* 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->minyminy; 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; } void uiBlockFlipOrder(uiBlock *block) { ListBase lb; uiBut *but, *next; float centy, miny=10000, maxy= -10000; for(but= block->buttons.first; but; but= but->next) { 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 uiBlockSetButmFunc(uiBlock *block, void (*menufunc)(void *arg, int event), void *arg) { block->butm_func= menufunc; block->butm_func_arg= arg; } void uiBlockSetFunc(uiBlock *block, void (*func)(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)(void *arg1, void *arg2), void *arg1, void *arg2) { but->func= func; but->func_arg1= arg1; but->func_arg2= arg2; } void uiDefIDPoinBut(uiBlock *block, uiIDPoinFuncFP func, 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); } 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; } /* 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; } 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); } /* ******************** PUPmenu ****************** */ short pupmenu(char *instr) { uiBlock *block; ListBase listb= {NULL, NULL}; int event; static int lastselected= 0; short width, height=0, mousexmove = 0, mouseymove, xmax, ymax, mval[2], val= -1; short a, startx, starty, endx, endy, boxh=TBOXH, x1, y1; static char laststring[UI_MAX_NAME_STR]; MenuData *md; /* block stuff first, need to know the font */ block= uiNewBlock(&listb, "menu", UI_EMBOSSP, UI_HELV, G.curscreen->mainwin); uiBlockSetFlag(block, UI_BLOCK_LOOP|UI_BLOCK_REDRAW|UI_BLOCK_RET_1|UI_BLOCK_NUMSELECT); block->themecol= TH_MENU_ITEM; md= decompose_menu_string(instr); /* size and location, title slightly bigger for bold */ if(md->title) width= 2*strlen(md->title)+BIF_GetStringWidth(uiBlockGetCurFont(block), md->title, (U.transopts && USER_TR_BUTTONS)); else width= 0; for(a=0; anitems; a++) { char *name= md->items[a].str; xmax= BIF_GetStringWidth(uiBlockGetCurFont(block), md->items[a].str, (U.transopts && USER_TR_BUTTONS)); if(xmax>width) width= xmax; if( strcmp(name, "%l")==0) height+= 6; else height+= boxh; } width+= 10; xmax = G.curscreen->sizex; ymax = G.curscreen->sizey; getmouseco_sc(mval); if(strncmp(laststring, instr, UI_MAX_NAME_STR-1)!=0) lastselected= 0; BLI_strncpy(laststring, instr, UI_MAX_NAME_STR); startx= mval[0]-(0.8*(width)); if(lastselected>=0 && lastselectednitems) { starty= mval[1]-height+boxh/2+lastselected*boxh; } else starty= mval[1]-height/2; mouseymove= 0; if(startx<10) startx= 10; if(starty<10) { mouseymove= 10-starty; starty= 10; } endx= startx+width; endy= starty+height; if(endx>xmax) { endx= xmax-10; startx= endx-width; } if(endy>ymax-20) { mouseymove= ymax-endy-20; endy= ymax-20; starty= endy-height; } if(mouseymove) { ui_warp_pointer(mval[0], mouseymove+mval[1]); mousexmove= mval[0]; mouseymove= mval[1]; } /* here we go! */ if(md->title) { uiBut *bt; uiSetCurFont(block, UI_HELVB); bt= uiDefBut(block, LABEL, 0, md->title, startx, (short)(starty+md->nitems*boxh), width, boxh, NULL, 0.0, 0.0, 0, 0, ""); bt->flag= UI_TEXT_LEFT; uiSetCurFont(block, UI_HELV); } y1= starty + boxh*(md->nitems-1); x1= startx; for(a=0; anitems; a++) { char *name= md->items[a].str; if( strcmp(name, "%l")==0) { uiDefBut(block, SEPR, B_NOP, "", x1, y1, width, 6, NULL, 0, 0.0, 0, 0, ""); y1 -= 6; } else { uiDefButS(block, BUTM, B_NOP, name, x1, y1, width, boxh-1, &val, (float) md->items[a].retval, 0.0, 0, 0, ""); y1 -= boxh; } } uiBoundsBlock(block, 2); event= uiDoBlocks(&listb, 0); /* calculate last selected */ lastselected= 0; for(a=0; anitems; a++) { if(val==md->items[a].retval) lastselected= a; } menudata_free(md); if(mouseymove && (event & UI_RETURN_OUT)==0) ui_warp_pointer(mousexmove, mouseymove); return val; } short pupmenu_col(char *instr, int maxrow) { uiBlock *block; ListBase listb= {NULL, NULL}; int columns, rows; short mousemove[2], mval[2], event; int width, height, xmax, ymax, val= -1; int a, startx, starty, endx, endy, boxh=TBOXH, x1, y1; MenuData *md; block= uiNewBlock(&listb, "menu", UI_EMBOSSP, UI_HELV, G.curscreen->mainwin); uiBlockSetFlag(block, UI_BLOCK_LOOP|UI_BLOCK_REDRAW|UI_BLOCK_RET_1|UI_BLOCK_NUMSELECT); block->themecol= TH_MENU_ITEM; md= decompose_menu_string(instr); /* collumns and row calculation */ columns= (md->nitems+maxrow)/maxrow; if (columns<1) columns= 1; rows= (int) md->nitems/columns; if (rows<1) rows= 1; while (rows*columns<(md->nitems+columns) ) rows++; /* size and location */ if(md->title) width= 2*strlen(md->title)+BIF_GetStringWidth(uiBlockGetCurFont(block), md->title, (U.transopts & USER_TR_BUTTONS)); else width= 0; for(a=0; anitems; a++) { xmax= BIF_GetStringWidth(uiBlockGetCurFont(block), md->items[a].str, (U.transopts & USER_TR_BUTTONS)); if(xmax>width) width= xmax; } width+= 10; if (width<50) width=50; boxh= TBOXH; height= rows*boxh; if (md->title) height+= boxh; xmax = G.curscreen->sizex; ymax = G.curscreen->sizey; getmouseco_sc(mval); /* find active item */ #if 0 fvalue= ui_get_but_val(but); for(a=0; anitems; a++) { if( md->items[a].retval== (int)fvalue ) break; } #endif /* no active item? */ if(a==md->nitems) { if(md->title) a= -1; else a= 0; } if(a>0) startx = mval[0]-width/2 - ((int)(a)/rows)*width; else startx= mval[0]-width/2; starty = mval[1]-height + boxh/2 + ((a)%rows)*boxh; if (md->title) starty+= boxh; mousemove[0]= mousemove[1]= 0; if(startx<10) { mousemove[0]= 10-startx; startx= 10; } if(starty<10) { mousemove[1]= 10-starty; starty= 10; } endx= startx+width*columns; endy= starty+height; if(endx>xmax) { mousemove[0]= xmax-endx-10; endx= xmax-10; startx= endx-width*columns; } if(endy>ymax) { mousemove[1]= ymax-endy-10; endy= ymax-10; starty= endy-height; } ui_warp_pointer(mval[0]+mousemove[0], mval[1]+mousemove[1]); mousemove[0]= mval[0]; mousemove[1]= mval[1]; /* here we go! */ if(md->title) { uiBut *bt; uiSetCurFont(block, UI_HELVB); bt= uiDefBut(block, LABEL, 0, md->title, startx, (short)(starty+rows*boxh), (short)width, (short)boxh, NULL, 0.0, 0.0, 0, 0, ""); uiSetCurFont(block, UI_HELV); bt->flag= UI_TEXT_LEFT; } for(a=0; anitems; a++) { char *name= md->items[a].str; x1= startx + width*((int)a/rows); y1= starty - boxh*(a%rows) + (rows-1)*boxh; if( strcmp(name, "%l")==0){ uiDefBut(block, SEPR, B_NOP, "", x1, y1, width, 6, NULL, 0, 0.0, 0, 0, ""); y1 -= 6; } else { uiDefButI(block, BUTM, B_NOP, name, x1, y1, width, boxh-1, &val, (float) md->items[a].retval, 0.0, 0, 0, ""); y1 -= boxh; } //uiDefButI(block, BUTM, B_NOP, md->items[a].str, x1, y1, (short)(width-(rows>1)), (short)(boxh-1), &val, (float)md->items[a].retval, 0.0, 0, 0, ""); } uiBoundsBlock(block, 3); event= uiDoBlocks(&listb, 0); menudata_free(md); if((event & UI_RETURN_OUT)==0) ui_warp_pointer(mousemove[0], mousemove[1]); return val; }