← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/src/interface_panel.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/interface_panel.c
1
1
/**
2
 
 * $Id: interface_panel.c,v 1.18 2004/04/07 14:05:53 ton Exp $
 
2
 * $Id: interface_panel.c,v 1.30 2005/03/19 21:08:12 zuster Exp $
3
3
 *
4
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5
5
 *
49
49
#include <unistd.h>
50
50
#else
51
51
#include <io.h>
52
 
#include "BLI_winstuff.h"
53
52
#endif   
54
53
 
55
54
#include "MEM_guardedalloc.h"
114
113
        
115
114
}
116
115
 
117
 
void gl_round_box_topshade(float minx, float miny, float maxx, float maxy, float rad)
 
116
void gl_round_box(int mode, float minx, float miny, float maxx, float maxy, float rad)
 
117
{
 
118
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
 
119
                          {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
 
120
        int a;
 
121
        
 
122
        /* mult */
 
123
        for(a=0; a<7; a++) {
 
124
                vec[a][0]*= rad; vec[a][1]*= rad;
 
125
        }
 
126
 
 
127
        glBegin(mode);
 
128
 
 
129
        /* start with corner right-bottom */
 
130
        if(roundboxtype & 4) {
 
131
                glVertex2f( maxx-rad, miny);
 
132
                for(a=0; a<7; a++) {
 
133
                        glVertex2f( maxx-rad+vec[a][0], miny+vec[a][1]);
 
134
                }
 
135
                glVertex2f( maxx, miny+rad);
 
136
        }
 
137
        else glVertex2f( maxx, miny);
 
138
        
 
139
        /* corner right-top */
 
140
        if(roundboxtype & 2) {
 
141
                glVertex2f( maxx, maxy-rad);
 
142
                for(a=0; a<7; a++) {
 
143
                        glVertex2f( maxx-vec[a][1], maxy-rad+vec[a][0]);
 
144
                }
 
145
                glVertex2f( maxx-rad, maxy);
 
146
        }
 
147
        else glVertex2f( maxx, maxy);
 
148
        
 
149
        /* corner left-top */
 
150
        if(roundboxtype & 1) {
 
151
                glVertex2f( minx+rad, maxy);
 
152
                for(a=0; a<7; a++) {
 
153
                        glVertex2f( minx+rad-vec[a][0], maxy-vec[a][1]);
 
154
                }
 
155
                glVertex2f( minx, maxy-rad);
 
156
        }
 
157
        else glVertex2f( minx, maxy);
 
158
        
 
159
        /* corner left-bottom */
 
160
        if(roundboxtype & 8) {
 
161
                glVertex2f( minx, miny+rad);
 
162
                for(a=0; a<7; a++) {
 
163
                        glVertex2f( minx+vec[a][1], miny+rad-vec[a][0]);
 
164
                }
 
165
                glVertex2f( minx+rad, miny);
 
166
        }
 
167
        else glVertex2f( minx, miny);
 
168
        
 
169
        glEnd();
 
170
}
 
171
 
 
172
static void round_box_shade_col(float *col1, float *col2, float fac)
 
173
{
 
174
        float col[3];
 
175
 
 
176
        col[0]= (fac*col1[0] + (1.0-fac)*col2[0]);
 
177
        col[1]= (fac*col1[1] + (1.0-fac)*col2[1]);
 
178
        col[2]= (fac*col1[2] + (1.0-fac)*col2[2]);
 
179
        
 
180
        glColor3fv(col);
 
181
}
 
182
 
 
183
/* linear horizontal shade within button or in outline */
 
184
void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown)
 
185
{
 
186
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
 
187
                          {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
 
188
        float div= maxy-miny;
 
189
        float coltop[3], coldown[3], color[4];
 
190
        int a;
 
191
        
 
192
        /* mult */
 
193
        for(a=0; a<7; a++) {
 
194
                vec[a][0]*= rad; vec[a][1]*= rad;
 
195
        }
 
196
        /* get current color, needs to be outside of glBegin/End */
 
197
        glGetFloatv(GL_CURRENT_COLOR, color);
 
198
 
 
199
        /* 'shade' defines strength of shading */       
 
200
        coltop[0]= color[0]+shadetop; if(coltop[0]>1.0) coltop[0]= 1.0;
 
201
        coltop[1]= color[1]+shadetop; if(coltop[1]>1.0) coltop[1]= 1.0;
 
202
        coltop[2]= color[2]+shadetop; if(coltop[2]>1.0) coltop[2]= 1.0;
 
203
        coldown[0]= color[0]+shadedown; if(coldown[0]<0.0) coldown[0]= 0.0;
 
204
        coldown[1]= color[1]+shadedown; if(coldown[1]<0.0) coldown[1]= 0.0;
 
205
        coldown[2]= color[2]+shadedown; if(coldown[2]<0.0) coldown[2]= 0.0;
 
206
 
 
207
        glShadeModel(GL_SMOOTH);
 
208
        glBegin(mode);
 
209
 
 
210
        /* start with corner right-bottom */
 
211
        if(roundboxtype & 4) {
 
212
                
 
213
                round_box_shade_col(coltop, coldown, 0.0);
 
214
                glVertex2f( maxx-rad, miny);
 
215
                
 
216
                for(a=0; a<7; a++) {
 
217
                        round_box_shade_col(coltop, coldown, vec[a][1]/div);
 
218
                        glVertex2f( maxx-rad+vec[a][0], miny+vec[a][1]);
 
219
                }
 
220
                
 
221
                round_box_shade_col(coltop, coldown, rad/div);
 
222
                glVertex2f( maxx, miny+rad);
 
223
        }
 
224
        else {
 
225
                round_box_shade_col(coltop, coldown, 0.0);
 
226
                glVertex2f( maxx, miny);
 
227
        }
 
228
        
 
229
        /* corner right-top */
 
230
        if(roundboxtype & 2) {
 
231
                
 
232
                round_box_shade_col(coltop, coldown, (div-rad)/div);
 
233
                glVertex2f( maxx, maxy-rad);
 
234
                
 
235
                for(a=0; a<7; a++) {
 
236
                        round_box_shade_col(coltop, coldown, (div-rad+vec[a][1])/div);
 
237
                        glVertex2f( maxx-vec[a][1], maxy-rad+vec[a][0]);
 
238
                }
 
239
                round_box_shade_col(coltop, coldown, 1.0);
 
240
                glVertex2f( maxx-rad, maxy);
 
241
        }
 
242
        else {
 
243
                round_box_shade_col(coltop, coldown, 1.0);
 
244
                glVertex2f( maxx, maxy);
 
245
        }
 
246
        
 
247
        /* corner left-top */
 
248
        if(roundboxtype & 1) {
 
249
                
 
250
                round_box_shade_col(coltop, coldown, 1.0);
 
251
                glVertex2f( minx+rad, maxy);
 
252
                
 
253
                for(a=0; a<7; a++) {
 
254
                        round_box_shade_col(coltop, coldown, (div-vec[a][1])/div);
 
255
                        glVertex2f( minx+rad-vec[a][0], maxy-vec[a][1]);
 
256
                }
 
257
                
 
258
                round_box_shade_col(coltop, coldown, (div-rad)/div);
 
259
                glVertex2f( minx, maxy-rad);
 
260
        }
 
261
        else {
 
262
                round_box_shade_col(coltop, coldown, 1.0);
 
263
                glVertex2f( minx, maxy);
 
264
        }
 
265
        
 
266
        /* corner left-bottom */
 
267
        if(roundboxtype & 8) {
 
268
                
 
269
                round_box_shade_col(coltop, coldown, rad/div);
 
270
                glVertex2f( minx, miny+rad);
 
271
                
 
272
                for(a=0; a<7; a++) {
 
273
                        round_box_shade_col(coltop, coldown, (rad-vec[a][1])/div);
 
274
                        glVertex2f( minx+vec[a][1], miny+rad-vec[a][0]);
 
275
                }
 
276
                
 
277
                round_box_shade_col(coltop, coldown, 0.0);
 
278
                glVertex2f( minx+rad, miny);
 
279
        }
 
280
        else {
 
281
                round_box_shade_col(coltop, coldown, 0.0);
 
282
                glVertex2f( minx, miny);
 
283
        }
 
284
        
 
285
        glEnd();
 
286
        glShadeModel(GL_FLAT);
 
287
}
 
288
 
 
289
/* only for headers */
 
290
static void gl_round_box_topshade(float minx, float miny, float maxx, float maxy, float rad)
118
291
{
119
292
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
120
293
                          {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
161
334
        glEnd();
162
335
}
163
336
 
164
 
 
165
 
void gl_round_box(float minx, float miny, float maxx, float maxy, float rad)
166
 
{
167
 
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
168
 
                          {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
169
 
        int a;
170
 
        
171
 
        /* mult */
172
 
        for(a=0; a<7; a++) {
173
 
                vec[a][0]*= rad; vec[a][1]*= rad;
174
 
        }
175
 
 
176
 
        /* start with corner right-bottom */
177
 
        if(roundboxtype & 4) {
178
 
                glVertex2f( maxx-rad, miny);
179
 
                for(a=0; a<7; a++) {
180
 
                        glVertex2f( maxx-rad+vec[a][0], miny+vec[a][1]);
181
 
                }
182
 
                glVertex2f( maxx, miny+rad);
183
 
        }
184
 
        else glVertex2f( maxx, miny);
185
 
        
186
 
        /* corner right-top */
187
 
        if(roundboxtype & 2) {
188
 
                glVertex2f( maxx, maxy-rad);
189
 
                for(a=0; a<7; a++) {
190
 
                        glVertex2f( maxx-vec[a][1], maxy-rad+vec[a][0]);
191
 
                }
192
 
                glVertex2f( maxx-rad, maxy);
193
 
        }
194
 
        else glVertex2f( maxx, maxy);
195
 
        
196
 
        /* corner left-top */
197
 
        if(roundboxtype & 1) {
198
 
                glVertex2f( minx+rad, maxy);
199
 
                for(a=0; a<7; a++) {
200
 
                        glVertex2f( minx+rad-vec[a][0], maxy-vec[a][1]);
201
 
                }
202
 
                glVertex2f( minx, maxy-rad);
203
 
        }
204
 
        else glVertex2f( minx, maxy);
205
 
        
206
 
        /* corner left-bottom */
207
 
        if(roundboxtype & 8) {
208
 
                glVertex2f( minx, miny+rad);
209
 
                for(a=0; a<7; a++) {
210
 
                        glVertex2f( minx+vec[a][1], miny+rad-vec[a][0]);
211
 
                }
212
 
                glVertex2f( minx+rad, miny);
213
 
        }
214
 
        else glVertex2f( minx, miny);
215
 
        
216
 
}
217
 
 
218
337
/* for headers and floating panels */
219
 
void uiRoundBoxEmboss(float minx, float miny, float maxx, float maxy, float rad)
 
338
void uiRoundBoxEmboss(float minx, float miny, float maxx, float maxy, float rad, int active)
220
339
{
221
340
        float color[4];
222
341
        
229
348
        }
230
349
        
231
350
        /* solid part */
232
 
        glBegin(GL_POLYGON);
233
 
        gl_round_box(minx, miny, maxx, maxy, rad);
234
 
        glEnd();
 
351
        //if(active)
 
352
        //      gl_round_box_shade(GL_POLYGON, minx, miny, maxx, maxy, rad, 0.10, -0.05);
 
353
        // else
 
354
        /* shading doesnt work for certain buttons yet (pulldown) need smarter buffer caching (ton) �*/
 
355
        gl_round_box(GL_POLYGON, minx, miny, maxx, maxy, rad);
235
356
        
236
357
        /* set antialias line */
237
358
        glEnable( GL_LINE_SMOOTH );
242
363
        gl_round_box_topshade(minx+1, miny+1, maxx-1, maxy-1, rad);
243
364
 
244
365
        /* total outline */
245
 
        if(roundboxtype & UI_RB_ALPHA) glColor4ub(0,0,0, 128); else glColor4ub(0,0,0, 255);
246
 
        glBegin(GL_LINE_LOOP);
247
 
        gl_round_box(minx, miny, maxx, maxy, rad);
248
 
        glEnd();
 
366
        if(roundboxtype & UI_RB_ALPHA) glColor4ub(0,0,0, 128); else glColor4ub(0,0,0, 200);
 
367
        gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
249
368
   
250
369
        glDisable( GL_LINE_SMOOTH );
251
370
 
276
395
        glEnable( GL_BLEND );
277
396
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
278
397
 
279
 
        glBegin(GL_LINE_LOOP);
280
 
        gl_round_box(minx, miny, maxx, maxy, rad);
281
 
        glEnd();
 
398
        gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
282
399
   
283
400
        glDisable( GL_BLEND );
284
401
        glDisable( GL_LINE_SMOOTH );
300
417
        }
301
418
        
302
419
        /* solid part */
303
 
        glBegin(GL_POLYGON);
304
 
        gl_round_box(minx, miny, maxx, maxy, rad);
305
 
        glEnd();
 
420
        gl_round_box(GL_POLYGON, minx, miny, maxx, maxy, rad);
306
421
        
307
422
        /* set antialias line */
308
423
        glEnable( GL_LINE_SMOOTH );
309
424
        glEnable( GL_BLEND );
310
425
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
311
426
 
312
 
        glBegin(GL_LINE_LOOP);
313
 
        gl_round_box(minx, miny, maxx, maxy, rad);
314
 
        glEnd();
 
427
        gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
315
428
   
316
429
        glDisable( GL_BLEND );
317
430
        glDisable( GL_LINE_SMOOTH );
420
533
        pa->active= 1;
421
534
        pa->control= pnl_control;
422
535
        
423
 
        if(pnl_control & UI_PNL_TO_MOUSE) {
 
536
        /* global control over this feature; UI_PNL_TO_MOUSE only called for hotkey panels */
 
537
        if(U.uiflag & USER_PANELPINNED);
 
538
        else if(pnl_control & UI_PNL_TO_MOUSE) {
424
539
                short mval[2];
425
540
                
426
541
                Mat4CpyMat4(UIwinmat, block->winmat);   // can be first event here
497
612
        if( block->maxx-block->minx > block->panel->sizex - 2*PNL_SAFETY ) {
498
613
                facx= (block->panel->sizex - (2*PNL_SAFETY))/( block->maxx-block->minx );
499
614
        }
500
 
        else centrex= (block->panel->sizex-( block->maxx-block->minx ) - PNL_SAFETY)/2;
 
615
        else centrex= (block->panel->sizex-( block->maxx-block->minx ) - 2*PNL_SAFETY)/2;
501
616
        
502
617
        // tabsy= PNL_HEADER*panel_has_tabs(block->panel);
503
618
        if( (block->maxy-block->miny) > block->panel->sizey - 2*PNL_SAFETY - tabsy) {
761
876
                }
762
877
                pa= pa->next;
763
878
        }
764
 
        
 
879
 
765
880
        pnl_icons= PNL_ICON+8;
766
881
        if(panel->control & UI_PNL_CLOSE) pnl_icons+= PNL_ICON;
767
882
 
768
883
        if(nr==1) {
 
884
                // full header
 
885
                BIF_ThemeColorShade(TH_HEADER, -30);
 
886
                uiSetRoundBox(3);
 
887
                uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
 
888
 
769
889
                /* active tab */
 
890
                /* draw text label */
770
891
                BIF_ThemeColor(TH_TEXT_HI);
771
 
                glRasterPos2f(4+block->minx+pnl_icons, block->maxy+5);
 
892
                ui_rasterpos_safe(4+block->minx+pnl_icons, block->maxy+5, block->aspect);
772
893
                BIF_DrawString(block->curfont, block->panel->panelname, (U.transopts & USER_TR_BUTTONS));
773
894
                return;
774
895
        }
775
896
        
 
897
        // tabbed, full header brighter
 
898
        //BIF_ThemeColorShade(TH_HEADER, 0);
 
899
        //uiSetRoundBox(3);
 
900
        //uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
 
901
 
776
902
        a= 0;
777
903
        width= (panel->sizex - 3 - pnl_icons - PNL_ICON)/nr;
778
904
        pa= curarea->panels.first;
780
906
                if(pa->active==0);
781
907
                else if(pa==panel) {
782
908
                        /* active tab */
 
909
                
 
910
                        /* draw the active tab */
783
911
                        uiSetRoundBox(3);
784
912
                        BIF_ThemeColorShade(TH_HEADER, -3);
785
913
                        uiRoundBox(2+pnl_icons+a*width, panel->sizey-1, pnl_icons+(a+1)*width, panel->sizey+PNL_HEADER-3, 8);
786
914
 
 
915
                        /* draw the active text label */
787
916
                        BIF_ThemeColor(TH_TEXT);
788
 
                        glRasterPos2f(16+pnl_icons+a*width, panel->sizey+4);
 
917
                        ui_rasterpos_safe(16+pnl_icons+a*width, panel->sizey+4, block->aspect);
789
918
                        str= ui_block_cut_str(block, pa->panelname, (short)(width-10));
790
919
                        BIF_DrawString(block->curfont, str, (U.transopts & USER_TR_BUTTONS));
791
920
 
792
921
                        a++;
793
922
                }
794
923
                else if(pa->paneltab==panel) {
795
 
                        /* not active tab */
796
 
                        
 
924
                        /* draw an inactive tab */
 
925
                        uiSetRoundBox(3);
797
926
                        BIF_ThemeColorShade(TH_HEADER, -60);
798
927
                        uiRoundBox(2+pnl_icons+a*width, panel->sizey, pnl_icons+(a+1)*width, panel->sizey+PNL_HEADER-3, 8);
799
928
                        
 
929
                        /* draw an inactive tab label */
800
930
                        BIF_ThemeColorShade(TH_TEXT_HI, -40);
801
 
                        glRasterPos2f(16+pnl_icons+a*width, panel->sizey+4);
 
931
                        ui_rasterpos_safe(16+pnl_icons+a*width, panel->sizey+4, block->aspect);
802
932
                        str= ui_block_cut_str(block, pa->panelname, (short)(width-10));
803
933
                        BIF_DrawString(block->curfont, str, (U.transopts & USER_TR_BUTTONS));
804
934
                                
823
953
        
824
954
        if(panel->paneltab) return;
825
955
 
 
956
        /* if the panel is minimised vertically:
 
957
         * (------)
 
958
         */
826
959
        if(panel->flag & PNL_CLOSEDY) {
 
960
                /* draw a little rounded box, the size of the header */
827
961
                uiSetRoundBox(15);
828
962
                BIF_ThemeColorShade(TH_HEADER, -30);
829
 
                uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 10);
 
963
                uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
830
964
                
831
 
                // title
 
965
                /* title */
832
966
                ofsx= PNL_ICON+8;
833
967
                if(panel->control & UI_PNL_CLOSE) ofsx+= PNL_ICON;
834
968
                BIF_ThemeColor(TH_TEXT_HI);
835
 
                glRasterPos2f(4+block->minx+ofsx, block->maxy+5);
 
969
                ui_rasterpos_safe(4+block->minx+ofsx, block->maxy+5, block->aspect);
836
970
                BIF_DrawString(block->curfont, panel->panelname, (U.transopts & USER_TR_BUTTONS));
837
971
 
838
 
                //  border
 
972
                /*  border */
839
973
                if(panel->flag & PNL_SELECT) {
840
974
                        BIF_ThemeColorShade(TH_HEADER, -120);
841
 
                        uiRoundRect(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 10);
 
975
                        uiRoundRect(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
842
976
                }
 
977
                /* if it's being overlapped by a panel being dragged */
843
978
                if(panel->flag & PNL_OVERLAP) {
844
979
                        BIF_ThemeColor(TH_TEXT_HI);
845
 
                        uiRoundRect(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 10);
 
980
                        uiRoundRect(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
846
981
                }
847
982
        
848
983
        }
 
984
        /* if the panel is minimised horizontally:
 
985
         * /-\
 
986
         *  |
 
987
         *  |
 
988
         *  |
 
989
         * \_/
 
990
         */
849
991
        else if(panel->flag & PNL_CLOSEDX) {
850
992
                char str[4];
851
993
                int a, end, ofs;
852
994
                
 
995
                /* draw a little rounded box, the size of the header, rotated 90 deg */ 
853
996
                uiSetRoundBox(15);
854
997
                BIF_ThemeColorShade(TH_HEADER, -30);
855
 
                uiRoundBox(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 10);
 
998
                uiRoundBox(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 8);
856
999
        
857
 
                // title, only capitals for now
 
1000
                /* title, only the initial character for now */
858
1001
                BIF_ThemeColor(TH_TEXT_HI);
859
1002
                str[1]= 0;
860
1003
                end= strlen(panel->panelname);
862
1005
                for(a=0; a<end; a++) {
863
1006
                        str[0]= panel->panelname[a];
864
1007
                        if( isupper(str[0]) ) {
865
 
                                glRasterPos2f(block->minx+5, block->maxy-ofs);
 
1008
                                ui_rasterpos_safe(block->minx+5, block->maxy-ofs, block->aspect);
866
1009
                                BIF_DrawString(block->curfont, str, 0);
867
1010
                                ofs+= 15;
868
1011
                        }
869
1012
                }
870
1013
                
871
 
                //  border
 
1014
                /* border */
872
1015
                if(panel->flag & PNL_SELECT) {
873
1016
                        BIF_ThemeColorShade(TH_HEADER, -120);
874
 
                        uiRoundRect(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 10);
 
1017
                        uiRoundRect(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 8);
875
1018
                }
876
1019
                if(panel->flag & PNL_OVERLAP) {
877
1020
                        BIF_ThemeColor(TH_TEXT_HI);
878
 
                        uiRoundRect(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 10);
 
1021
                        uiRoundRect(block->minx, block->miny, block->minx+PNL_HEADER, block->maxy+PNL_HEADER, 8);
879
1022
                }
880
1023
        
881
1024
        }
 
1025
        /* an open panel */
882
1026
        else {
883
 
                
884
 
                uiSetRoundBox(3);
885
 
 
 
1027
                /* all panels now... */
886
1028
                if(panel->control & UI_PNL_SOLID) {
887
1029
                        BIF_ThemeColorShade(TH_HEADER, -30);
888
 
                        uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 10);
 
1030
 
 
1031
                        uiSetRoundBox(3);
 
1032
                        uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
 
1033
 
889
1034
                        // blend now for panels in 3d window, test...
890
1035
                        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
891
1036
                        glEnable(GL_BLEND);
892
1037
                        BIF_ThemeColor4(TH_PANEL);
893
 
                        glRectf(block->minx, block->miny, block->maxx, block->maxy);
894
 
                        
 
1038
                        
 
1039
                        uiSetRoundBox(12);
 
1040
                        uiRoundBox(block->minx, block->miny, block->maxx, block->maxy, 8);
 
1041
 
 
1042
                        // glRectf(block->minx, block->miny, block->maxx, block->maxy);
 
1043
                        
 
1044
                        /* shadow */
 
1045
                        /*
895
1046
                        glColor4ub(0, 0, 0, 40);
896
1047
                        
897
1048
                        fdrawline(block->minx+2, block->miny-1, block->maxx+1, block->miny-1);
901
1052
                        
902
1053
                        fdrawline(block->minx+3, block->miny-2, block->maxx+2, block->miny-2);
903
1054
                        fdrawline(block->maxx+2, block->miny-2, block->maxx+2, block->maxy+6);  
904
 
 
 
1055
                        
 
1056
                        */
 
1057
                        
905
1058
                        glDisable(GL_BLEND);
906
1059
                }
 
1060
                /* floating panel */
907
1061
                else if(panel->control & UI_PNL_TRANSP) {
908
1062
                        BIF_ThemeColorShade(TH_HEADER, -30);
909
 
                        uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 10);
 
1063
                        uiSetRoundBox(3);
 
1064
                        uiRoundBox(block->minx, block->maxy, block->maxx, block->maxy+PNL_HEADER, 8);
910
1065
                        
911
1066
                        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
912
1067
                        glEnable(GL_BLEND);
916
1071
                        glDisable(GL_BLEND);
917
1072
                }
918
1073
                
919
 
                
 
1074
                /* draw the title, tabs, etc in the header */
920
1075
                ui_draw_panel_header(block);
921
1076
 
922
 
                //  border
923
 
                uiSetRoundBox(3);
 
1077
                /* in some occasions, draw a border */
924
1078
                if(panel->flag & PNL_SELECT) {
 
1079
                        if(panel->control & UI_PNL_SOLID) uiSetRoundBox(15);
 
1080
                        else uiSetRoundBox(3);
 
1081
                        
925
1082
                        BIF_ThemeColorShade(TH_HEADER, -120);
926
 
                        uiRoundRect(block->minx, block->miny, block->maxx, block->maxy+PNL_HEADER, 10);
 
1083
                        uiRoundRect(block->minx, block->miny, block->maxx, block->maxy+PNL_HEADER, 8);
927
1084
                }
928
1085
                if(panel->flag & PNL_OVERLAP) {
 
1086
                        if(panel->control & UI_PNL_SOLID) uiSetRoundBox(15);
 
1087
                        else uiSetRoundBox(3);
 
1088
                        
929
1089
                        BIF_ThemeColor(TH_TEXT_HI);
930
 
                        uiRoundRect(block->minx, block->miny, block->maxx, block->maxy+PNL_HEADER, 10);
 
1090
                        uiRoundRect(block->minx, block->miny, block->maxx, block->maxy+PNL_HEADER, 8);
931
1091
                }
932
1092
                
933
1093
                /* and a soft shadow-line for now */
 
1094
                /*
934
1095
                glEnable( GL_BLEND );
935
1096
                glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
936
1097
                glColor4ub(0, 0, 0, 50);
937
1098
                fdrawline(block->maxx, block->miny, block->maxx, block->maxy+PNL_HEADER/2);
938
1099
                fdrawline(block->minx, block->miny, block->maxx, block->miny);
939
1100
                glDisable(GL_BLEND);
 
1101
                */
940
1102
 
941
1103
        }
942
1104
        
1006
1168
        Panel *pa, *orig;
1007
1169
} PanelSort;
1008
1170
 
 
1171
/* note about sorting;
 
1172
   the sortcounter has a lower value for new panels being added.
 
1173
   however, that only works to insert a single panel, when more new panels get
 
1174
   added the coordinates of existing panels and the previously stored to-be-insterted
 
1175
   panels do not match for sorting */
 
1176
 
1009
1177
static int find_leftmost_panel(const void *a1, const void *a2)
1010
1178
{
1011
1179
        const PanelSort *ps1=a1, *ps2=a2;
1012
1180
        
1013
1181
        if( ps1->pa->ofsx > ps2->pa->ofsx) return 1;
1014
1182
        else if( ps1->pa->ofsx < ps2->pa->ofsx) return -1;
 
1183
        else if( ps1->pa->sortcounter > ps2->pa->sortcounter) return 1;
 
1184
        else if( ps1->pa->sortcounter < ps2->pa->sortcounter) return -1;
1015
1185
 
1016
1186
        return 0;
1017
1187
}
1023
1193
        
1024
1194
        if( ps1->pa->ofsy < ps2->pa->ofsy) return 1;
1025
1195
        else if( ps1->pa->ofsy > ps2->pa->ofsy) return -1;
 
1196
        else if( ps1->pa->sortcounter > ps2->pa->sortcounter) return 1;
 
1197
        else if( ps1->pa->sortcounter < ps2->pa->sortcounter) return -1;
1026
1198
        
1027
1199
        return 0;
1028
1200
}
1034
1206
        SpaceButs *sbuts= sa->spacedata.first;
1035
1207
        Panel *pa;
1036
1208
        PanelSort *ps, *panelsort, *psnext;
 
1209
        static int sortcounter= 0;
1037
1210
        int a, tot=0, done;
1038
1211
        
1039
1212
        if(sa->spacetype!=SPACE_BUTS) {
1115
1288
                }
1116
1289
        }
1117
1290
 
 
1291
        /* set counter, used for sorting with newly added panels */
 
1292
        sortcounter++;
 
1293
        for(pa= sa->panels.first; pa; pa= pa->next) {
 
1294
                if(pa->active) pa->sortcounter= sortcounter;
 
1295
        }
 
1296
 
1118
1297
        /* free panelsort array */
1119
1298
        ps= panelsort;
1120
1299
        for(a=0; a<tot; a++, ps++) {
1221
1400
                                
1222
1401
                                if(minx<0.0) dx= -minx;
1223
1402
                                else if(maxx > (float)sa->winx) dx= sa->winx-maxx;
 
1403
                                if( minx + dx < 0.0) dx= -minx; // when panel cant fit, put it fixed here
 
1404
                                        
1224
1405
                                if(miny<0.0) dy= -miny;
1225
1406
                                else if(maxy > (float)sa->winy) dy= sa->winy-maxy;
1226
 
 
 
1407
                                if( miny + dy < 0.0) dy= -miny; // when panel cant fit, put it fixed here
 
1408
                                
1227
1409
                                block->panel->ofsx+= dx/sl->blockscale;
1228
1410
                                block->panel->ofsy+= dy/sl->blockscale;
1229
1411
 
1334
1516
/* ------------ panel drag ---------------- */
1335
1517
 
1336
1518
 
1337
 
void ui_drag_panel(uiBlock *block)
 
1519
static void ui_drag_panel(uiBlock *block)
1338
1520
{
1339
1521
        Panel *panel= block->panel;
1340
1522
        short align=0, first=1, ofsx, ofsy, dx=0, dy=0, dxo=0, dyo=0, mval[2], mvalo[2];