Region scrollbar fix!
authorTon Roosendaal <ton@blender.org>
Wed, 26 Dec 2012 13:05:39 +0000 (13:05 +0000)
committerTon Roosendaal <ton@blender.org>
Wed, 26 Dec 2012 13:05:39 +0000 (13:05 +0000)
Now scrollbars correctly hide and show, making space for the actual contents
in a region. It solves several old hacks, and puts view2d code a bit more
back in control as well.

Implementation notes:

- The view2d mask feature is working again
- The #define V2D_SCROLL_HORIZONTAL_HIDE means: "turn on hiding".
- Code for UI_view2d_region_reinit() is enforcing better standard view settings

But... two hack/patches needed to be added:

- Region panel drawing: if after generating the button panels it appears
  a scroller hides or reveils, it calls all the generating code again.
  (a simple scale doesn't work due to rounding differences in layout code)

- View2d code that maps 'tot' and 'cur' rects: if this code detects that
  the mask changes, it calcs the map code again.

Also a bugfix (issue in 2.65)

- The left/bottom area split widget was drawing 1 pixel too large sometimes,
  leaving bad trails on moving area dividers.

19 files changed:
source/blender/blenloader/intern/versioning_250.c
source/blender/editors/include/UI_interface.h
source/blender/editors/include/UI_view2d.h
source/blender/editors/interface/interface.c
source/blender/editors/interface/interface_handlers.c
source/blender/editors/interface/interface_panel.c
source/blender/editors/interface/view2d.c
source/blender/editors/interface/view2d_ops.c
source/blender/editors/screen/area.c
source/blender/editors/space_action/action_draw.c
source/blender/editors/space_action/space_action.c
source/blender/editors/space_file/file_draw.c
source/blender/editors/space_graph/space_graph.c
source/blender/editors/space_outliner/outliner_draw.c
source/blender/editors/space_outliner/outliner_intern.h
source/blender/editors/space_outliner/space_outliner.c
source/blender/editors/space_userpref/space_userpref.c
source/blender/makesdna/DNA_view2d_types.h
source/blender/windowmanager/intern/wm_window.c

index 1521739258e0b69461bdd98123da8ae450d09e5b..f4d841fd22aafbd10cfffeb24a5a2d5d7897fdc1 100644 (file)
@@ -292,7 +292,7 @@ static void area_add_window_regions(ScrArea *sa, SpaceLink *sl, ListBase *lb)
                                        memcpy(&ar->v2d, &soops->v2d, sizeof(View2D));
 
                                        ar->v2d.scroll &= ~V2D_SCROLL_LEFT;
-                                       ar->v2d.scroll |= (V2D_SCROLL_RIGHT|V2D_SCROLL_BOTTOM_O);
+                                       ar->v2d.scroll |= (V2D_SCROLL_RIGHT|V2D_SCROLL_BOTTOM);
                                        ar->v2d.align = (V2D_ALIGN_NO_NEG_X|V2D_ALIGN_NO_POS_Y);
                                        ar->v2d.keepzoom |= (V2D_LOCKZOOM_X|V2D_LOCKZOOM_Y|V2D_KEEPASPECT);
                                        ar->v2d.keeptot = V2D_KEEPTOT_STRICT;
@@ -415,7 +415,7 @@ static void area_add_window_regions(ScrArea *sa, SpaceLink *sl, ListBase *lb)
                                        ar->v2d.tot.ymax = ar->winy;
                                        ar->v2d.cur = ar->v2d.tot;
                                        ar->regiontype = RGN_TYPE_WINDOW;
-                                       ar->v2d.scroll = (V2D_SCROLL_RIGHT|V2D_SCROLL_BOTTOM_O);
+                                       ar->v2d.scroll = (V2D_SCROLL_RIGHT|V2D_SCROLL_BOTTOM);
                                        ar->v2d.align = (V2D_ALIGN_NO_NEG_X|V2D_ALIGN_NO_POS_Y);
                                        ar->v2d.keepzoom = (V2D_LOCKZOOM_X|V2D_LOCKZOOM_Y|V2D_LIMITZOOM|V2D_KEEPASPECT);
                                        break;
index 90f8779b2c716d75d371106b5d4ce6f717df203e..9a04138e72eedfb3fcd73a19b444d6cebf68a10a 100644 (file)
@@ -658,6 +658,7 @@ void uiDrawPanels(const struct bContext *C, struct ARegion *ar);
 
 struct Panel *uiBeginPanel(struct ScrArea *sa, struct ARegion *ar, uiBlock *block, struct PanelType *pt, int *open);
 void uiEndPanel(uiBlock *block, int width, int height);
+void uiScalePanels(struct ARegion *ar, float new_width);
 
 /* Handlers
  *
index 3ae1e93dc3dcb1d823497eb834b71355fb151e98..81a0f526049c0d206a96ebf5a64f1f75f84bfdfd 100644 (file)
@@ -148,7 +148,6 @@ typedef struct View2DScrollers View2DScrollers;
 void UI_view2d_region_reinit(struct View2D *v2d, short type, int winx, int winy);
 
 void UI_view2d_curRect_validate(struct View2D *v2d);
-void UI_view2d_curRect_validate_resize(struct View2D *v2d, int resize);
 void UI_view2d_curRect_reset(struct View2D *v2d);
 void UI_view2d_sync(struct bScreen *screen, struct ScrArea *sa, struct View2D *v2dcur, int flag);
 
index 25f85883d9c0b2a2898c58cea3797c500c31d852..1d26cbd344b20cd6d77d8a9175fe8d465caaede0 100644 (file)
@@ -2666,6 +2666,8 @@ static uiBut *ui_def_but(uiBlock *block, int type, int retval, const char *str,
        
        /* we could do some more error checks here */
        if ((type & BUTTYPE) == LABEL) {
+               if ((poin != NULL || min != 0.0f || max != 0.0f || (a1 == 0.0f && a2 != 0.0f) || (a1 != 0.0f && a1 != 1.0f)))
+                       printf("blah\n");
                BLI_assert((poin != NULL || min != 0.0f || max != 0.0f || (a1 == 0.0f && a2 != 0.0f) || (a1 != 0.0f && a1 != 1.0f)) == FALSE);
        }
 
index 958334fb476037e9573b88ffefc93969f6e7588b..9988224e0ab62b5da52f4e3e5bb6ed987bc5abb2 100644 (file)
@@ -5248,32 +5248,15 @@ static int ui_mouse_inside_region(ARegion *ar, int x, int y)
         */
        if (ar->v2d.mask.xmin != ar->v2d.mask.xmax) {
                View2D *v2d = &ar->v2d;
-               rcti mask_rct;
                int mx, my;
                
                /* convert window coordinates to region coordinates */
                mx = x;
                my = y;
                ui_window_to_region(ar, &mx, &my);
-               
-               /* make a copy of the mask rect, and tweak accordingly for hidden scrollbars */
-               mask_rct = v2d->mask;
-               
-               if (v2d->scroll & (V2D_SCROLL_VERTICAL_HIDE | V2D_SCROLL_VERTICAL_FULLR)) {
-                       if (v2d->scroll & V2D_SCROLL_LEFT)
-                               mask_rct.xmin = v2d->vert.xmin;
-                       else if (v2d->scroll & V2D_SCROLL_RIGHT)
-                               mask_rct.xmax = v2d->vert.xmax;
-               }
-               if (v2d->scroll & (V2D_SCROLL_HORIZONTAL_HIDE | V2D_SCROLL_HORIZONTAL_FULLR)) {
-                       if (v2d->scroll & (V2D_SCROLL_BOTTOM | V2D_SCROLL_BOTTOM_O))
-                               mask_rct.ymin = v2d->hor.ymin;
-                       else if (v2d->scroll & V2D_SCROLL_TOP)
-                               mask_rct.ymax = v2d->hor.ymax;
-               }
-               
+
                /* check if in the rect */
-               if (!BLI_rcti_isect_pt(&mask_rct, mx, my)) 
+               if (!BLI_rcti_isect_pt(&v2d->mask, mx, my))
                        return 0;
        }
        
index 5b6a609e4d21b20525c3c613eebfff075774fe47..9fbf2fe88982011ad29f9c5f4661b72d0c209be4 100644 (file)
@@ -112,7 +112,7 @@ static int panel_aligned(ScrArea *sa, ARegion *ar)
        else if (sa->spacetype == SPACE_FILE && ar->regiontype == RGN_TYPE_CHANNELS)
                return BUT_VERTICAL;
        else if (sa->spacetype == SPACE_IMAGE && ar->regiontype == RGN_TYPE_PREVIEW)
-               return BUT_VERTICAL; 
+               return BUT_VERTICAL;
        else if (ELEM3(ar->regiontype, RGN_TYPE_UI, RGN_TYPE_TOOLS, RGN_TYPE_TOOL_PROPS))
                return BUT_VERTICAL;
        
@@ -812,8 +812,8 @@ static void ui_panels_size(ScrArea *sa, ARegion *ar, int *x, int *y)
 {
        Panel *pa;
        int align = panel_aligned(sa, ar);
-       int sizex = UI_PANEL_WIDTH;
-       int sizey = UI_PANEL_WIDTH;
+       int sizex = 0;
+       int sizey = 0;
 
        /* compute size taken up by panels, for setting in view2d */
        for (pa = ar->panels.first; pa; pa = pa->next) {
@@ -834,6 +834,11 @@ static void ui_panels_size(ScrArea *sa, ARegion *ar, int *x, int *y)
                }
        }
 
+       if (sizex == 0)
+               sizex = UI_PANEL_WIDTH;
+       if (sizey == 0)
+               sizey = -UI_PANEL_WIDTH;
+       
        *x = sizex;
        *y = sizey;
 }
@@ -956,6 +961,25 @@ void uiDrawPanels(const bContext *C, ARegion *ar)
        }
 }
 
+void uiScalePanels(ARegion *ar, float new_width)
+{
+       uiBlock *block;
+       uiBut *but;
+       
+       for (block = ar->uiblocks.first; block; block = block->next) {
+               if (block->panel) {
+                       float fac = new_width / (float)block->panel->sizex;
+                       printf("scaled %f\n", fac);
+                       block->panel->sizex = new_width;
+                       
+                       for (but = block->buttons.first; but; but = but->next) {
+                               but->rect.xmin *= fac;
+                               but->rect.xmax *= fac;
+                       }
+               }
+       }
+}
+
 /* ------------ panel merging ---------------- */
 
 static void check_panel_overlap(ARegion *ar, Panel *panel)
index 190d90b3c364669fe5625a07e4e89817e54bef31..d0d631e14a527c15d5b0a892863805a2ffca43f4 100644 (file)
@@ -60,6 +60,8 @@
 
 #include "interface_intern.h"
 
+static void ui_view2d_curRect_validate_resize(View2D *v2d, int resize, int mask_scrollers);
+
 /* *********************************************************************** */
 
 /* XXX still unresolved: scrolls hide/unhide vs region mask handling */
  */
 static int view2d_scroll_mapped(int scroll)
 {
-       if (scroll & V2D_SCROLL_HORIZONTAL_HIDE)
+       if (scroll & V2D_SCROLL_HORIZONTAL_FULLR)
                scroll &= ~(V2D_SCROLL_HORIZONTAL);
-       if (scroll & V2D_SCROLL_VERTICAL_HIDE)
+       if (scroll & V2D_SCROLL_VERTICAL_FULLR)
                scroll &= ~(V2D_SCROLL_VERTICAL);
        return scroll;
 }
 
 /* called each time cur changes, to dynamically update masks */
-static void view2d_masks(View2D *v2d)
+static void view2d_masks(View2D *v2d, int check_scrollers)
 {
        int scroll;
        
@@ -90,19 +92,26 @@ static void view2d_masks(View2D *v2d)
        v2d->mask.xmax = v2d->winx - 1; /* -1 yes! masks are pixels */
        v2d->mask.ymax = v2d->winy - 1;
 
-#if 0
-       /* XXX see above */
-       v2d->scroll &= ~(V2D_SCROLL_HORIZONTAL_HIDE | V2D_SCROLL_VERTICAL_HIDE);
-       /* check size if: */
-       if (v2d->scroll & V2D_SCROLL_HORIZONTAL)
-               if (!(v2d->scroll & V2D_SCROLL_SCALE_HORIZONTAL))
-                       if (BLI_rctf_size_x(&v2d->tot) <= BLI_rcti_size_x(&v2d->cur))
-                               v2d->scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
-       if (v2d->scroll & V2D_SCROLL_VERTICAL)
-               if (!(v2d->scroll & V2D_SCROLL_SCALE_VERTICAL))
-                       if (BLI_rctf_size_y(&v2d->tot) <= BLI_rctf_size_y(&v2d->cur))
-                               v2d->scroll |= V2D_SCROLL_VERTICAL_HIDE;
-#endif
+       if (check_scrollers) {
+               /* check size if hiding flag is set: */
+               if (v2d->scroll & V2D_SCROLL_HORIZONTAL_HIDE) {
+                       if (!(v2d->scroll & V2D_SCROLL_SCALE_HORIZONTAL)) {
+                               if (BLI_rctf_size_x(&v2d->tot) > BLI_rctf_size_x(&v2d->cur))
+                                       v2d->scroll &= ~V2D_SCROLL_HORIZONTAL_FULLR;
+                               else
+                                       v2d->scroll |= V2D_SCROLL_HORIZONTAL_FULLR;
+                       }
+               }
+               if (v2d->scroll & V2D_SCROLL_VERTICAL_HIDE) {
+                       if (!(v2d->scroll & V2D_SCROLL_SCALE_VERTICAL)) {
+                               if (BLI_rctf_size_y(&v2d->tot) + 0.01f > BLI_rctf_size_y(&v2d->cur))
+                                       v2d->scroll &= ~V2D_SCROLL_VERTICAL_FULLR;
+                               else
+                                       v2d->scroll |= V2D_SCROLL_VERTICAL_FULLR;
+                       }
+               }
+       }
+       
        scroll = view2d_scroll_mapped(v2d->scroll);
        
        /* scrollers shrink mask area, but should be based off regionsize 
@@ -126,8 +135,8 @@ static void view2d_masks(View2D *v2d)
                }
                
                /* horizontal scroller */
-               if (scroll & (V2D_SCROLL_BOTTOM | V2D_SCROLL_BOTTOM_O)) {
-                       /* on bottom edge of region (V2D_SCROLL_BOTTOM_O is outliner, the other is for standard) */
+               if (scroll & (V2D_SCROLL_BOTTOM)) {
+                       /* on bottom edge of region */
                        v2d->hor = v2d->mask;
                        v2d->hor.ymax = V2D_SCROLL_HEIGHT;
                        v2d->mask.ymin = v2d->hor.ymax + 1;
@@ -142,8 +151,8 @@ static void view2d_masks(View2D *v2d)
                /* adjust vertical scroller if there's a horizontal scroller, to leave corner free */
                if (scroll & V2D_SCROLL_VERTICAL) {
                        /* just set y min/max for vertical scroller to y min/max of mask as appropriate */
-                       if (scroll & (V2D_SCROLL_BOTTOM | V2D_SCROLL_BOTTOM_O)) {
-                               /* on bottom edge of region (V2D_SCROLL_BOTTOM_O is outliner, the other is for standard) */
+                       if (scroll & (V2D_SCROLL_BOTTOM)) {
+                               /* on bottom edge of region */
                                v2d->vert.ymin = v2d->mask.ymin;
                        }
                        else if (scroll & V2D_SCROLL_TOP) {
@@ -152,7 +161,6 @@ static void view2d_masks(View2D *v2d)
                        }
                }
        }
-       
 }
 
 /* Refresh and Validation */
@@ -165,163 +173,173 @@ static void view2d_masks(View2D *v2d)
  */
 void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
 {
-       short tot_changed = 0, init = 0;
+       short tot_changed = 0, do_init;
        uiStyle *style = UI_GetStyle();
 
-       /* initialize data if there is a need for such */
-       if ((v2d->flag & V2D_IS_INITIALISED) == 0) {
-               /* set initialized flag so that View2D doesn't get reinitialised next time again */
-               v2d->flag |= V2D_IS_INITIALISED;
-
-               init = 1;
+       do_init = (v2d->flag & V2D_IS_INITIALISED) == 0;
                
-               /* see eView2D_CommonViewTypes in UI_view2d.h for available view presets */
-               switch (type) {
-                       /* 'standard view' - optimum setup for 'standard' view behavior,
-                        *  that should be used new views as basis for their
-                        *  own unique View2D settings, which should be used instead of this in most cases...
+       /* see eView2D_CommonViewTypes in UI_view2d.h for available view presets */
+       switch (type) {
+               /* 'standard view' - optimum setup for 'standard' view behavior,
+                *  that should be used new views as basis for their
+                *  own unique View2D settings, which should be used instead of this in most cases...
+                */
+               case V2D_COMMONVIEW_STANDARD:
+               {
+                       /* for now, aspect ratio should be maintained, and zoom is clamped within sane default limits */
+                       v2d->keepzoom = (V2D_KEEPASPECT | V2D_LIMITZOOM);
+                       v2d->minzoom = 0.01f;
+                       v2d->maxzoom = 1000.0f;
+                       
+                       /* tot rect and cur should be same size, and aligned using 'standard' OpenGL coordinates for now 
+                        *      - region can resize 'tot' later to fit other data
+                        *      - keeptot is only within bounds, as strict locking is not that critical
+                        *      - view is aligned for (0,0) -> (winx-1, winy-1) setup
                         */
-                       case V2D_COMMONVIEW_STANDARD:
-                       {
-                               /* for now, aspect ratio should be maintained, and zoom is clamped within sane default limits */
-                               v2d->keepzoom = (V2D_KEEPASPECT | V2D_LIMITZOOM);
-                               v2d->minzoom = 0.01f;
-                               v2d->maxzoom = 1000.0f;
-                               
-                               /* tot rect and cur should be same size, and aligned using 'standard' OpenGL coordinates for now 
-                                *      - region can resize 'tot' later to fit other data
-                                *      - keeptot is only within bounds, as strict locking is not that critical
-                                *      - view is aligned for (0,0) -> (winx-1, winy-1) setup
-                                */
-                               v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
-                               v2d->keeptot = V2D_KEEPTOT_BOUNDS;
-                               
+                       v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
+                       v2d->keeptot = V2D_KEEPTOT_BOUNDS;
+                       
+                       if (do_init) {
                                v2d->tot.xmin = v2d->tot.ymin = 0.0f;
                                v2d->tot.xmax = (float)(winx - 1);
                                v2d->tot.ymax = (float)(winy - 1);
                                
                                v2d->cur = v2d->tot;
-                               
-                               /* scrollers - should we have these by default? */
-                               /* XXX for now, we don't override this, or set it either! */
                        }
-                       break;
+                       /* scrollers - should we have these by default? */
+                       /* XXX for now, we don't override this, or set it either! */
+               }
+               break;
+               
+               /* 'list/channel view' - zoom, aspect ratio, and alignment restrictions are set here */
+               case V2D_COMMONVIEW_LIST:
+               {
+                       /* zoom + aspect ratio are locked */
+                       v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
+                       v2d->minzoom = v2d->maxzoom = 1.0f;
                        
-                       /* 'list/channel view' - zoom, aspect ratio, and alignment restrictions are set here */
-                       case V2D_COMMONVIEW_LIST:
-                       {
-                               /* zoom + aspect ratio are locked */
-                               v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
-                               v2d->minzoom = v2d->maxzoom = 1.0f;
-                               
-                               /* tot rect has strictly regulated placement, and must only occur in +/- quadrant */
-                               v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
-                               v2d->keeptot = V2D_KEEPTOT_STRICT;
-                               tot_changed = 1;
-                               
-                               /* scroller settings are currently not set here... that is left for regions... */
-                       }
-                       break;
-                               
-                       /* 'stack view' - practically the same as list/channel view, except is located in the pos y half instead. 
-                        *  zoom, aspect ratio, and alignment restrictions are set here */
-                       case V2D_COMMONVIEW_STACK:
-                       {
-                               /* zoom + aspect ratio are locked */
-                               v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
-                               v2d->minzoom = v2d->maxzoom = 1.0f;
-                               
-                               /* tot rect has strictly regulated placement, and must only occur in +/+ quadrant */
-                               v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
-                               v2d->keeptot = V2D_KEEPTOT_STRICT;
-                               tot_changed = 1;
-                               
-                               /* scroller settings are currently not set here... that is left for regions... */
-                       }
-                       break;
+                       /* tot rect has strictly regulated placement, and must only occur in +/- quadrant */
+                       v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
+                       v2d->keeptot = V2D_KEEPTOT_STRICT;
+                       tot_changed = do_init;
+                       
+                       /* scroller settings are currently not set here... that is left for regions... */
+               }
+               break;
+                       
+               /* 'stack view' - practically the same as list/channel view, except is located in the pos y half instead. 
+                *  zoom, aspect ratio, and alignment restrictions are set here */
+               case V2D_COMMONVIEW_STACK:
+               {
+                       /* zoom + aspect ratio are locked */
+                       v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
+                       v2d->minzoom = v2d->maxzoom = 1.0f;
+                       
+                       /* tot rect has strictly regulated placement, and must only occur in +/+ quadrant */
+                       v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
+                       v2d->keeptot = V2D_KEEPTOT_STRICT;
+                       tot_changed = do_init;
+                       
+                       /* scroller settings are currently not set here... that is left for regions... */
+               }
+               break;
+                       
+               /* 'header' regions - zoom, aspect ratio, alignment, and panning restrictions are set here */
+               case V2D_COMMONVIEW_HEADER:
+               {
+                       /* zoom + aspect ratio are locked */
+                       v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
+                       v2d->minzoom = v2d->maxzoom = 1.0f;
+                       
+                       if (do_init) {
+                               v2d->tot.xmin = 0.0f;
+                               v2d->tot.xmax = winx;
+                               v2d->tot.ymin = 0.0f;
+                               v2d->tot.ymax = winy;
+                               v2d->cur = v2d->tot;
                                
-                       /* 'header' regions - zoom, aspect ratio, alignment, and panning restrictions are set here */
-                       case V2D_COMMONVIEW_HEADER:
-                       {
-                               /* zoom + aspect ratio are locked */
-                               v2d->keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
-                               v2d->minzoom = v2d->maxzoom = 1.0f;
                                v2d->min[0] = v2d->max[0] = (float)(winx - 1);
                                v2d->min[1] = v2d->max[1] = (float)(winy - 1);
-                               
-                               /* tot rect has strictly regulated placement, and must only occur in +/+ quadrant */
-                               v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
-                               v2d->keeptot = V2D_KEEPTOT_STRICT;
-                               tot_changed = 1;
-                               
-                               /* panning in y-axis is prohibited */
-                               v2d->keepofs = V2D_LOCKOFS_Y;
-                               
-                               /* absolutely no scrollers allowed */
-                               v2d->scroll = 0;
-                               
                        }
-                       break;
+                       /* tot rect has strictly regulated placement, and must only occur in +/+ quadrant */
+                       v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y);
+                       v2d->keeptot = V2D_KEEPTOT_STRICT;
+                       tot_changed = do_init;
+                       
+                       /* panning in y-axis is prohibited */
+                       v2d->keepofs = V2D_LOCKOFS_Y;
+                       
+                       /* absolutely no scrollers allowed */
+                       v2d->scroll = 0;
+                       
+               }
+               break;
+               
+               /* panels view, with horizontal/vertical align */
+               case V2D_COMMONVIEW_PANELS_UI:
+               {
                        
-                       /* panels view, with horizontal/vertical align */
-                       case V2D_COMMONVIEW_PANELS_UI:
-                       {
+                       /* for now, aspect ratio should be maintained, and zoom is clamped within sane default limits */
+                       v2d->keepzoom = (V2D_KEEPASPECT | V2D_LIMITZOOM | V2D_KEEPZOOM);
+                       v2d->minzoom = 0.5f;
+                       v2d->maxzoom = 2.0f;
+                       
+                       v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
+                       v2d->keeptot = V2D_KEEPTOT_BOUNDS;
+                       
+                       /* note, scroll is being flipped in ED_region_panels() drawing */
+                       v2d->scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
+                       v2d->scroll |= V2D_SCROLL_VERTICAL_HIDE;
+
+                       if (do_init) {
                                float panelzoom = (style) ? style->panelzoom : 1.0f;
+                               float scrolw = v2d->scroll & V2D_SCROLL_RIGHT ? V2D_SCROLL_WIDTH : 0.0f;
                                
-                               /* for now, aspect ratio should be maintained, and zoom is clamped within sane default limits */
-                               v2d->keepzoom = (V2D_KEEPASPECT | V2D_LIMITZOOM | V2D_KEEPZOOM);
-                               v2d->minzoom = 0.5f;
-                               v2d->maxzoom = 2.0f;
-                               //tot_changed = 1;
-                               
-                               v2d->align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
-                               v2d->keeptot = V2D_KEEPTOT_BOUNDS;
-                               
-                               v2d->scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
-                               v2d->scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
-                               v2d->scroll &= ~V2D_SCROLL_VERTICAL_HIDE;
-
                                v2d->tot.xmin = 0.0f;
-                               v2d->tot.xmax = winx;
+                               v2d->tot.xmax = winx - scrolw;
                                
                                v2d->tot.ymax = 0.0f;
                                v2d->tot.ymin = -winy;
                                
                                v2d->cur.xmin = 0.0f;
-                               /* bad workaround for keeping zoom level with scrollers */
-                               v2d->cur.xmax = (winx - V2D_SCROLL_WIDTH) * panelzoom;
+                               v2d->cur.xmax = (winx) * panelzoom - scrolw;
                                
                                v2d->cur.ymax = 0.0f;
                                v2d->cur.ymin = (-winy) * panelzoom;
                        }
-                       break;
-                               
-                       /* other view types are completely defined using their own settings already */
-                       default:
-                               /* we don't do anything here, as settings should be fine, but just make sure that rect */
-                               break;
                }
+               break;
+                       
+               /* other view types are completely defined using their own settings already */
+               default:
+                       /* we don't do anything here, as settings should be fine, but just make sure that rect */
+                       break;
        }
        
+       /* set initialized flag so that View2D doesn't get reinitialised next time again */
+       v2d->flag |= V2D_IS_INITIALISED;
+
        /* store view size */
        v2d->winx = winx;
        v2d->winy = winy;
        
-       /* set masks */
-       view2d_masks(v2d);
+       /* set masks (always do), but leave scroller scheck to totrect_set */
+       view2d_masks(v2d, 0);
        
        /* set 'tot' rect before setting cur? */
-       if (tot_changed) 
-               UI_view2d_totRect_set_resize(v2d, winx, winy, !init);
+       /* XXX confusing stuff here still - I made this function not check scroller hide - that happens in totrect_set */
+       if (tot_changed)
+               UI_view2d_totRect_set_resize(v2d, winx, winy, !do_init);
        else
-               UI_view2d_curRect_validate_resize(v2d, !init);
+               ui_view2d_curRect_validate_resize(v2d, !do_init, 0);
+       
 }
 
 /* Ensure View2D rects remain in a viable configuration 
  *     - cur is not allowed to be: larger than max, smaller than min, or outside of tot
  */
 // XXX pre2.5 -> this used to be called  test_view2d()
-void UI_view2d_curRect_validate_resize(View2D *v2d, int resize)
+static void ui_view2d_curRect_validate_resize(View2D *v2d, int resize, int mask_scrollers)
 {
        float totwidth, totheight, curwidth, curheight, width, height;
        float winx, winy;
@@ -715,12 +733,12 @@ void UI_view2d_curRect_validate_resize(View2D *v2d, int resize)
        }
        
        /* set masks */
-       view2d_masks(v2d);
+       view2d_masks(v2d, mask_scrollers);
 }
 
 void UI_view2d_curRect_validate(View2D *v2d)
 {
-       UI_view2d_curRect_validate_resize(v2d, 0);
+       ui_view2d_curRect_validate_resize(v2d, 0, 1);
 }
 
 /* ------------------ */
@@ -844,7 +862,7 @@ void UI_view2d_curRect_reset(View2D *v2d)
 /* Change the size of the maximum viewable area (i.e. 'tot' rect) */
 void UI_view2d_totRect_set_resize(View2D *v2d, int width, int height, int resize)
 {
-       int scroll = view2d_scroll_mapped(v2d->scroll);
+//     int scroll = view2d_scroll_mapped(v2d->scroll);
        
        /* don't do anything if either value is 0 */
        width = abs(width);
@@ -853,10 +871,10 @@ void UI_view2d_totRect_set_resize(View2D *v2d, int width, int height, int resize
        /* hrumf! */
        /* XXX: there are work arounds for this in the panel and file browse code. */
        /* round to int, because this is called with width + V2D_SCROLL_WIDTH */
-       if (scroll & V2D_SCROLL_HORIZONTAL) 
-               width -= (int)V2D_SCROLL_WIDTH;
-       if (scroll & V2D_SCROLL_VERTICAL) 
-               height -= (int)V2D_SCROLL_HEIGHT;
+//     if (scroll & V2D_SCROLL_HORIZONTAL)
+//             width -= (int)V2D_SCROLL_WIDTH;
+//     if (scroll & V2D_SCROLL_VERTICAL)
+//             height -= (int)V2D_SCROLL_HEIGHT;
        
        if (ELEM(0, width, height)) {
                if (G.debug & G_DEBUG)
@@ -903,12 +921,21 @@ void UI_view2d_totRect_set_resize(View2D *v2d, int width, int height, int resize
        }
        
        /* make sure that 'cur' rect is in a valid state as a result of these changes */
-       UI_view2d_curRect_validate_resize(v2d, resize);
+       ui_view2d_curRect_validate_resize(v2d, resize, 1);
+       
 }
 
 void UI_view2d_totRect_set(View2D *v2d, int width, int height)
 {
+       int scroll = view2d_scroll_mapped(v2d->scroll);
+
        UI_view2d_totRect_set_resize(v2d, width, height, 0);
+       
+       /* solve bad recursion... if scroller state changed, mask is different, so you get different rects */
+       if (scroll != view2d_scroll_mapped(v2d->scroll)) {
+               UI_view2d_totRect_set_resize(v2d, width, height, 0);
+       }
+       
 }
 
 int UI_view2d_tab_set(View2D *v2d, int tab)
@@ -1494,15 +1521,6 @@ View2DScrollers *UI_view2d_scrollers_calc(const bContext *C, View2D *v2d,
                        CLAMP(scrollers->hor_min, hor.xmin, hor.xmax - V2D_SCROLLER_HANDLE_SIZE);
                }
                
-               /* check whether sliders can disappear due to the full-range being used */
-               if (v2d->keeptot) {
-                       if ((fac1 <= 0.0f) && (fac2 >= 1.0f)) {
-                               v2d->scroll |= V2D_SCROLL_HORIZONTAL_FULLR;
-                               scrollers->horfull = 1;
-                       }
-                       else
-                               v2d->scroll &= ~V2D_SCROLL_HORIZONTAL_FULLR;
-               }
        }
        
        /* vertical scrollers */
@@ -1536,15 +1554,6 @@ View2DScrollers *UI_view2d_scrollers_calc(const bContext *C, View2D *v2d,
                        CLAMP(scrollers->vert_min, vert.ymin, vert.ymax - V2D_SCROLLER_HANDLE_SIZE);
                }
 
-               /* check whether sliders can disappear due to the full-range being used */
-               if (v2d->keeptot) {
-                       if ((fac1 <= 0.0f) && (fac2 >= 1.0f)) {
-                               v2d->scroll |= V2D_SCROLL_VERTICAL_FULLR;
-                               scrollers->vertfull = 1;
-                       }
-                       else
-                               v2d->scroll &= ~V2D_SCROLL_VERTICAL_FULLR;
-               }
        }
        
        /* grid markings on scrollbars */
@@ -1618,45 +1627,42 @@ void UI_view2d_scrollers_draw(const bContext *C, View2D *v2d, View2DScrollers *v
        
        /* horizontal scrollbar */
        if (scroll & V2D_SCROLL_HORIZONTAL) {
-               /* only draw scrollbar when it doesn't fill the entire space */
-               if (vs->horfull == 0) {
-                       bTheme *btheme = UI_GetTheme();
-                       uiWidgetColors wcol = btheme->tui.wcol_scroll;
-                       rcti slider;
-                       int state;
-                       unsigned char col[4];
-                       
-                       slider.xmin = vs->hor_min;
-                       slider.xmax = vs->hor_max;
-                       slider.ymin = hor.ymin;
-                       slider.ymax = hor.ymax;
-                       
-                       state = (v2d->scroll_ui & V2D_SCROLL_H_ACTIVE) ? UI_SCROLL_PRESSED : 0;
-                       
-                       /* show zoom handles if:
-                        *      - zooming on x-axis is allowed (no scroll otherwise)
-                        *      - slider bubble is large enough (no overdraw confusion)
-                        *      - scale is shown on the scroller 
-                        *        (workaround to make sure that button windows don't show these, 
-                        *              and only the time-grids with their zoomability can do so)
-                        */
-                       if ((v2d->keepzoom & V2D_LOCKZOOM_X) == 0 &&
-                           (v2d->scroll & V2D_SCROLL_SCALE_HORIZONTAL) &&
-                           (BLI_rcti_size_x(&slider) > V2D_SCROLLER_HANDLE_SIZE))
-                       {
-                               state |= UI_SCROLL_ARROWS;
-                       }
-                       
-                       /* clean rect behind slider, but not with transparent background */
-                       UI_GetThemeColor4ubv(TH_BACK, col);
-                       if (col[3] == 255) {
-                               glColor3ub(col[0], col[1], col[2]);
-                               glRecti(v2d->hor.xmin, v2d->hor.ymin, v2d->hor.xmax, v2d->hor.ymax);
-                       }
-                       
-                       uiWidgetScrollDraw(&wcol, &hor, &slider, state);
+               bTheme *btheme = UI_GetTheme();
+               uiWidgetColors wcol = btheme->tui.wcol_scroll;
+               rcti slider;
+               int state;
+               unsigned char col[4];
+               
+               slider.xmin = vs->hor_min;
+               slider.xmax = vs->hor_max;
+               slider.ymin = hor.ymin;
+               slider.ymax = hor.ymax;
+               
+               state = (v2d->scroll_ui & V2D_SCROLL_H_ACTIVE) ? UI_SCROLL_PRESSED : 0;
+               
+               /* show zoom handles if:
+                *      - zooming on x-axis is allowed (no scroll otherwise)
+                *      - slider bubble is large enough (no overdraw confusion)
+                *      - scale is shown on the scroller 
+                *        (workaround to make sure that button windows don't show these, 
+                *              and only the time-grids with their zoomability can do so)
+                */
+               if ((v2d->keepzoom & V2D_LOCKZOOM_X) == 0 &&
+                       (v2d->scroll & V2D_SCROLL_SCALE_HORIZONTAL) &&
+                       (BLI_rcti_size_x(&slider) > V2D_SCROLLER_HANDLE_SIZE))
+               {
+                       state |= UI_SCROLL_ARROWS;
                }
                
+               /* clean rect behind slider, but not with transparent background */
+               UI_GetThemeColor4ubv(TH_BACK, col);
+               if (col[3] == 255) {
+                       glColor3ub(col[0], col[1], col[2]);
+                       glRecti(v2d->hor.xmin, v2d->hor.ymin, v2d->hor.xmax, v2d->hor.ymax);
+               }
+               
+               uiWidgetScrollDraw(&wcol, &hor, &slider, state);
+               
                /* scale indicators */
                if ((scroll & V2D_SCROLL_SCALE_HORIZONTAL) && (vs->grid)) {
                        View2DGrid *grid = vs->grid;
@@ -1734,45 +1740,42 @@ void UI_view2d_scrollers_draw(const bContext *C, View2D *v2d, View2DScrollers *v
        
        /* vertical scrollbar */
        if (scroll & V2D_SCROLL_VERTICAL) {
-               /* only draw scrollbar when it doesn't fill the entire space */
-               if (vs->vertfull == 0) {
-                       bTheme *btheme = UI_GetTheme();
-                       uiWidgetColors wcol = btheme->tui.wcol_scroll;
-                       rcti slider;
-                       int state;
-                       unsigned char col[4];
-                       
-                       slider.xmin = vert.xmin;
-                       slider.xmax = vert.xmax;
-                       slider.ymin = vs->vert_min;
-                       slider.ymax = vs->vert_max;
-                       
-                       state = (v2d->scroll_ui & V2D_SCROLL_V_ACTIVE) ? UI_SCROLL_PRESSED : 0;
-                       
-                       /* show zoom handles if:
-                        *      - zooming on y-axis is allowed (no scroll otherwise)
-                        *      - slider bubble is large enough (no overdraw confusion)
-                        *      - scale is shown on the scroller 
-                        *        (workaround to make sure that button windows don't show these, 
-                        *              and only the time-grids with their zoomability can do so)
-                        */
-                       if ((v2d->keepzoom & V2D_LOCKZOOM_Y) == 0 &&
-                           (v2d->scroll & V2D_SCROLL_SCALE_VERTICAL) &&
-                           (BLI_rcti_size_y(&slider) > V2D_SCROLLER_HANDLE_SIZE))
-                       {
-                               state |= UI_SCROLL_ARROWS;
-                       }
-                       
-                       /* clean rect behind slider, but not with transparent background */
-                       UI_GetThemeColor4ubv(TH_BACK, col);
-                       if (col[3] == 255) {
-                               glColor3ub(col[0], col[1], col[2]);
-                               glRecti(v2d->vert.xmin, v2d->vert.ymin, v2d->vert.xmax, v2d->vert.ymax);
-                       }
-                       
-                       uiWidgetScrollDraw(&wcol, &vert, &slider, state);
+               bTheme *btheme = UI_GetTheme();
+               uiWidgetColors wcol = btheme->tui.wcol_scroll;
+               rcti slider;
+               int state;
+               unsigned char col[4];
+               
+               slider.xmin = vert.xmin;
+               slider.xmax = vert.xmax;
+               slider.ymin = vs->vert_min;
+               slider.ymax = vs->vert_max;
+               
+               state = (v2d->scroll_ui & V2D_SCROLL_V_ACTIVE) ? UI_SCROLL_PRESSED : 0;
+               
+               /* show zoom handles if:
+                *      - zooming on y-axis is allowed (no scroll otherwise)
+                *      - slider bubble is large enough (no overdraw confusion)
+                *      - scale is shown on the scroller 
+                *        (workaround to make sure that button windows don't show these, 
+                *              and only the time-grids with their zoomability can do so)
+                */
+               if ((v2d->keepzoom & V2D_LOCKZOOM_Y) == 0 &&
+                       (v2d->scroll & V2D_SCROLL_SCALE_VERTICAL) &&
+                       (BLI_rcti_size_y(&slider) > V2D_SCROLLER_HANDLE_SIZE))
+               {
+                       state |= UI_SCROLL_ARROWS;
                }
                
+               /* clean rect behind slider, but not with transparent background */
+               UI_GetThemeColor4ubv(TH_BACK, col);
+               if (col[3] == 255) {
+                       glColor3ub(col[0], col[1], col[2]);
+                       glRecti(v2d->vert.xmin, v2d->vert.ymin, v2d->vert.xmax, v2d->vert.ymax);
+               }
+               
+               uiWidgetScrollDraw(&wcol, &vert, &slider, state);
+               
                
                /* scale indiators */
                if ((scroll & V2D_SCROLL_SCALE_VERTICAL) && (vs->grid)) {
index 006644bf366083d3e9af41ffae7847bab29c6e96..8bea308e90a697e4c4c6d9a29f08d3c71ef2e83b 100644 (file)
@@ -1744,8 +1744,8 @@ static int scroller_activate_invoke(bContext *C, wmOperator *op, wmEvent *event)
                }
                
                /* zone is also inappropriate if scroller is not visible... */
-               if (((vsm->scroller == 'h') && (v2d->scroll & (V2D_SCROLL_HORIZONTAL_HIDE | V2D_SCROLL_HORIZONTAL_FULLR))) ||
-                   ((vsm->scroller == 'v') && (v2d->scroll & (V2D_SCROLL_VERTICAL_HIDE | V2D_SCROLL_VERTICAL_FULLR))) )
+               if (((vsm->scroller == 'h') && (v2d->scroll & (V2D_SCROLL_HORIZONTAL_FULLR))) ||
+                   ((vsm->scroller == 'v') && (v2d->scroll & (V2D_SCROLL_VERTICAL_FULLR))) )
                {
                        /* free customdata initialized */
                        scroller_activate_exit(C, op);
index fbdec3dd8ad4d7737f5c39f36d1c71d3b2c161c8..5d37765cd58735133f27d65b8e9ecaf4e7cb38e9 100644 (file)
@@ -574,8 +574,8 @@ static void area_azone_initialize(bScreen *screen, ScrArea *sa)
        az = (AZone *)MEM_callocN(sizeof(AZone), "actionzone");
        BLI_addtail(&(sa->actionzones), az);
        az->type = AZONE_AREA;
-       az->x1 = sa->totrct.xmin - 1;
-       az->y1 = sa->totrct.ymin - 1;
+       az->x1 = sa->totrct.xmin;
+       az->y1 = sa->totrct.ymin;
        az->x2 = sa->totrct.xmin + (AZONESPOT - 1);
        az->y2 = sa->totrct.ymin + (AZONESPOT - 1);
        BLI_rcti_init(&az->rect, az->x1, az->x2, az->y1, az->y2);
@@ -1300,6 +1300,9 @@ void ED_region_init(bContext *C, ARegion *ar)
        ar->winx = BLI_rcti_size_x(&ar->winrct) + 1;
        ar->winy = BLI_rcti_size_y(&ar->winrct) + 1;
        
+       /* v2d mask is used to subtract scrollbars from a 2d view. Needs initialize here. */
+       BLI_rcti_init(&ar->v2d.mask, 0, ar->winx - 1, 0, ar->winy -1);
+
        /* UI convention */
        wmOrtho2(-0.01f, ar->winx - 0.01f, -0.01f, ar->winy - 0.01f);
        glLoadIdentity();
@@ -1612,86 +1615,141 @@ void ED_region_panels(const bContext *C, ARegion *ar, int vertical, const char *
        View2D *v2d = &ar->v2d;
        View2DScrollers *scrollers;
        int x, y, xco, yco, w, em, triangle, open, newcontext = 0;
-       
+       int redo;
+       int scroll;
+
        if (contextnr >= 0)
                newcontext = UI_view2d_tab_set(v2d, contextnr);
-
+       
+       /* before setting the view */
        if (vertical) {
-               w = BLI_rctf_size_x(&v2d->cur);
-               em = (ar->type->prefsizex) ? UI_UNIT_Y / 2 : UI_UNIT_Y;
+               /* only allow scrolling in vertical direction */
+               v2d->keepofs |= V2D_LOCKOFS_X | V2D_KEEPOFS_Y;
+               v2d->keepofs &= ~(V2D_LOCKOFS_Y | V2D_KEEPOFS_X);
+               v2d->scroll &= ~(V2D_SCROLL_BOTTOM);
+               v2d->scroll |= (V2D_SCROLL_RIGHT);
        }
        else {
-               w = UI_PANEL_WIDTH;
-               em = (ar->type->prefsizex) ? UI_UNIT_Y / 2 : UI_UNIT_Y;
+               /* for now, allow scrolling in both directions (since layouts are optimized for vertical,
+                * they often don't fit in horizontal layout)
+                */
+               v2d->keepofs &= ~(V2D_LOCKOFS_X | V2D_LOCKOFS_Y | V2D_KEEPOFS_X | V2D_KEEPOFS_Y);
+               v2d->scroll |= (V2D_SCROLL_BOTTOM);
+               v2d->scroll &= ~(V2D_SCROLL_RIGHT);
        }
 
-       /* create panels */
-       uiBeginPanels(C, ar);
+       scroll = v2d->scroll;
+       
+       /* sortof hack - but we cannot predict the height of panels, until it's being generated */
+       /* the layout engine works with fixed width (from v2d->cur), which is being set at end of the loop */
+       /* in case scroller settings (hide flags) differ from previous, the whole loop gets done again */
+       for (redo = 2; redo > 0; redo--) {
+               
+               if (vertical) {
+                       w = BLI_rctf_size_x(&v2d->cur);
+                       em = (ar->type->prefsizex) ? UI_UNIT_Y / 2 : UI_UNIT_Y;
+               }
+               else {
+                       w = UI_PANEL_WIDTH;
+                       em = (ar->type->prefsizex) ? UI_UNIT_Y / 2 : UI_UNIT_Y;
+               }
+               
+               /* create panels */
+               uiBeginPanels(C, ar);
 
-       /* set view2d view matrix for scrolling (without scrollers) */
-       UI_view2d_view_ortho(v2d);
+               /* set view2d view matrix  - uiBeginBlock() stores it */
+               UI_view2d_view_ortho(v2d);
 
-       for (pt = ar->type->paneltypes.first; pt; pt = pt->next) {
-               /* verify context */
-               if (context)
-                       if (pt->context[0] && strcmp(context, pt->context) != 0)
-                               continue;
+               for (pt = ar->type->paneltypes.first; pt; pt = pt->next) {
+                       /* verify context */
+                       if (context)
+                               if (pt->context[0] && strcmp(context, pt->context) != 0)
+                                       continue;
 
-               /* draw panel */
-               if (pt->draw && (!pt->poll || pt->poll(C, pt))) {
-                       block = uiBeginBlock(C, ar, pt->idname, UI_EMBOSS);
-                       panel = uiBeginPanel(sa, ar, block, pt, &open);
+                       /* draw panel */
+                       if (pt->draw && (!pt->poll || pt->poll(C, pt))) {
+                               block = uiBeginBlock(C, ar, pt->idname, UI_EMBOSS);
+                               panel = uiBeginPanel(sa, ar, block, pt, &open);
 
-                       /* bad fixed values */
-                       triangle = (int)(UI_UNIT_Y * 1.1f);
+                               /* bad fixed values */
+                               triangle = (int)(UI_UNIT_Y * 1.1f);
 
-                       if (pt->draw_header && !(pt->flag & PNL_NO_HEADER) && (open || vertical)) {
-                               /* for enabled buttons */
-                               panel->layout = uiBlockLayout(block, UI_LAYOUT_HORIZONTAL, UI_LAYOUT_HEADER,
-                                                             triangle, (UI_UNIT_Y * 1.1f) + style->panelspace, UI_UNIT_Y, 1, style);
+                               if (pt->draw_header && !(pt->flag & PNL_NO_HEADER) && (open || vertical)) {
+                                       /* for enabled buttons */
+                                       panel->layout = uiBlockLayout(block, UI_LAYOUT_HORIZONTAL, UI_LAYOUT_HEADER,
+                                                                                                 triangle, (UI_UNIT_Y * 1.1f) + style->panelspace, UI_UNIT_Y, 1, style);
 
-                               pt->draw_header(C, panel);
+                                       pt->draw_header(C, panel);
 
-                               uiBlockLayoutResolve(block, &xco, &yco);
-                               panel->labelofs = xco - triangle;
-                               panel->layout = NULL;
-                       }
-                       else {
-                               panel->labelofs = 0;
-                       }
+                                       uiBlockLayoutResolve(block, &xco, &yco);
+                                       panel->labelofs = xco - triangle;
+                                       panel->layout = NULL;
+                               }
+                               else {
+                                       panel->labelofs = 0;
+                               }
 
-                       if (open) {
-                               short panelContext;
-                               
-                               /* panel context can either be toolbar region or normal panels region */
-                               if (ar->regiontype == RGN_TYPE_TOOLS)
-                                       panelContext = UI_LAYOUT_TOOLBAR;
-                               else
-                                       panelContext = UI_LAYOUT_PANEL;
-                               
-                               panel->layout = uiBlockLayout(block, UI_LAYOUT_VERTICAL, panelContext,
-                                                             style->panelspace, 0, w - 2 * style->panelspace, em, style);
+                               if (open) {
+                                       short panelContext;
+                                       
+                                       /* panel context can either be toolbar region or normal panels region */
+                                       if (ar->regiontype == RGN_TYPE_TOOLS)
+                                               panelContext = UI_LAYOUT_TOOLBAR;
+                                       else
+                                               panelContext = UI_LAYOUT_PANEL;
+                                       
+                                       panel->layout = uiBlockLayout(block, UI_LAYOUT_VERTICAL, panelContext,
+                                                                                                 style->panelspace, 0, w - 2 * style->panelspace, em, style);
 
-                               pt->draw(C, panel);
+                                       pt->draw(C, panel);
 
-                               uiBlockLayoutResolve(block, &xco, &yco);
-                               panel->layout = NULL;
+                                       uiBlockLayoutResolve(block, &xco, &yco);
+                                       panel->layout = NULL;
 
-                               yco -= 2 * style->panelspace;
-                               uiEndPanel(block, w, -yco);
-                       }
-                       else {
-                               yco = 0;
-                               uiEndPanel(block, w, 0);
+                                       yco -= 2 * style->panelspace;
+                                       uiEndPanel(block, w, -yco);
+                               }
+                               else {
+                                       yco = 0;
+                                       uiEndPanel(block, w, 0);
+                               }
+
+                               uiEndBlock(C, block);
                        }
+               }
 
-                       uiEndBlock(C, block);
+               /* align panels and return size */
+               uiEndPanels(C, ar, &x, &y);
+               
+               /* before setting the view */
+               if (vertical) {
+                       /* we always keep the scroll offset - so the total view gets increased with the scrolled away part */
+                       if (v2d->cur.ymax < - 0.001f)
+                               y = min_ii(y, v2d->cur.ymin);
+                       
+                       y = -y;
+               }
+               else {
+                       /* don't jump back when panels close or hide */
+                       if (!newcontext)
+                               x = max_ii(x, v2d->cur.xmax);
+                       y = -y;
+               }
+               
+               /* this also changes the 'cur' */
+               UI_view2d_totRect_set(v2d, x, y);
+               
+               if (scroll != v2d->scroll) {
+                       /* Note: this code scales fine, but because of rounding differences, positions of elements
+                        * flip +1 or -1 pixel compared to redoing the entire layout again.
+                        * Leaving in commented code for future tests */
+                       /* uiScalePanels(ar, BLI_rctf_size_x(&v2d->cur));
+                          break; */
                }
+               else break;
        }
-
-       /* align panels and return size */
-       uiEndPanels(C, ar, &x, &y);
-
+       
+       
        /* clear */
        if (ar->overlap) {
                /* view should be in pixelspace */
@@ -1706,36 +1764,6 @@ void ED_region_panels(const bContext *C, ARegion *ar, int vertical, const char *
                glClear(GL_COLOR_BUFFER_BIT);
        }
        
-       /* before setting the view */
-       if (vertical) {
-               /* only allow scrolling in vertical direction */
-               v2d->keepofs |= V2D_LOCKOFS_X | V2D_KEEPOFS_Y;
-               v2d->keepofs &= ~(V2D_LOCKOFS_Y | V2D_KEEPOFS_X);
-               v2d->scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
-               v2d->scroll &= ~V2D_SCROLL_VERTICAL_HIDE;
-
-               /* ensure tot is set correctly, to keep views on bottons, with sliders */
-               y = min_ii(y, v2d->cur.ymin);
-               y = -y;
-       }
-       else {
-               /* for now, allow scrolling in both directions (since layouts are optimized for vertical,
-                * they often don't fit in horizontal layout)
-                */
-               v2d->keepofs &= ~(V2D_LOCKOFS_X | V2D_LOCKOFS_Y | V2D_KEEPOFS_X | V2D_KEEPOFS_Y);
-               //v2d->keepofs |= V2D_LOCKOFS_Y|V2D_KEEPOFS_X;
-               //v2d->keepofs &= ~(V2D_LOCKOFS_X|V2D_KEEPOFS_Y);
-               v2d->scroll |= V2D_SCROLL_VERTICAL_HIDE;
-               v2d->scroll &= ~V2D_SCROLL_HORIZONTAL_HIDE;
-
-               /* don't jump back when panels close or hide */
-               if (!newcontext)
-                       x = max_ii(x, v2d->cur.xmax);
-               y = -y;
-       }
-
-       /* +V2D_SCROLL_HEIGHT is workaround to set the actual height (needs to be int) */
-       UI_view2d_totRect_set(v2d, x + (int)V2D_SCROLL_WIDTH, y + (int)V2D_SCROLL_HEIGHT);
 
        /* set the view */
        UI_view2d_view_ortho(v2d);
@@ -1756,16 +1784,9 @@ void ED_region_panels_init(wmWindowManager *wm, ARegion *ar)
 {
        wmKeyMap *keymap;
        
-       /* XXX quick hacks for files saved with 2.5 already (i.e. the builtin defaults file)
-        * scrollbars for button regions */
-       ar->v2d.scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
-       ar->v2d.scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
-       ar->v2d.scroll &= ~V2D_SCROLL_VERTICAL_HIDE;
-       ar->v2d.keepzoom |= V2D_KEEPZOOM;
-
-       /* correctly initialized User-Prefs? */
-       if (!(ar->v2d.align & V2D_ALIGN_NO_POS_Y))
-               ar->v2d.flag &= ~V2D_IS_INITIALISED;
+       /* used for correctly initialized User-Prefs only?  */
+//     if (!(ar->v2d.align & V2D_ALIGN_NO_POS_Y))
+//             ar->v2d.flag &= ~V2D_IS_INITIALISED;
 
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_PANELS_UI, ar->winx, ar->winy);
 
@@ -1828,6 +1849,7 @@ void ED_region_header(const bContext *C, ARegion *ar)
 
 void ED_region_header_init(ARegion *ar)
 {
+       ar->v2d.flag &= ~V2D_IS_INITIALISED;
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_HEADER, ar->winx, ar->winy);
 }
 
index 9bd7d2a44ca9cfb0db69f5cd65a0b82012f881f0..4b1954c8889339ea49a7283d7678998c76424a9a 100644 (file)
@@ -82,13 +82,7 @@ void draw_channel_names(bContext *C, bAnimContext *ac, ARegion *ar)
        filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
        items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
        
-       /* Update max-extent of channels here (taking into account scrollers):
-        *  - this is done to allow the channel list to be scrollable, but must be done here
-        *    to avoid regenerating the list again and/or also because channels list is drawn first
-        *      - offset of ACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
-        *        start of list offset, and the second is as a correction for the scrollers.
-        */
-       height = ((items * ACHANNEL_STEP) + (ACHANNEL_HEIGHT * 2));
+       height = ((items * ACHANNEL_STEP) + (ACHANNEL_HEIGHT));
        if (height > BLI_rcti_size_y(&v2d->mask)) {
                /* don't use totrect set, as the width stays the same 
                 * (NOTE: this is ok here, the configuration is pretty straightforward) 
@@ -199,13 +193,7 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *ar)
        filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);
        items = ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
        
-       /* Update max-extent of channels here (taking into account scrollers):
-        *  - this is done to allow the channel list to be scrollable, but must be done here
-        *    to avoid regenerating the list again and/or also because channels list is drawn first
-        *      - offset of ACHANNEL_HEIGHT*2 is added to the height of the channels, as first is for 
-        *        start of list offset, and the second is as a correction for the scrollers.
-        */
-       height = ((items * ACHANNEL_STEP) + (ACHANNEL_HEIGHT * 2));
+       height = ((items * ACHANNEL_STEP) + (ACHANNEL_HEIGHT));
        /* don't use totrect set, as the width stays the same 
         * (NOTE: this is ok here, the configuration is pretty straightforward) 
         */
index c5f3ccee101559dd78e9b634f18b5fddfaaea034..e0ca589c1fb793eab0aecd3c2404e929d90ef899 100644 (file)
@@ -219,6 +219,9 @@ static void action_channel_area_init(wmWindowManager *wm, ARegion *ar)
 {
        wmKeyMap *keymap;
        
+       /* ensure the 2d view sync works - main region has bottom scroller */
+       ar->v2d.scroll = V2D_SCROLL_BOTTOM;
+       
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_LIST, ar->winx, ar->winy);
        
        /* own keymap */
@@ -231,7 +234,6 @@ static void action_channel_area_draw(const bContext *C, ARegion *ar)
        /* draw entirely, view changes should be handled here */
        bAnimContext ac;
        View2D *v2d = &ar->v2d;
-       View2DScrollers *scrollers;
        
        /* clear and setup matrix */
        UI_ThemeClearColor(TH_BACK);
@@ -247,10 +249,7 @@ static void action_channel_area_draw(const bContext *C, ARegion *ar)
        /* reset view matrix */
        UI_view2d_view_restore(C);
        
-       /* scrollers */
-       scrollers = UI_view2d_scrollers_calc(C, v2d, V2D_ARG_DUMMY, V2D_ARG_DUMMY, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
-       UI_view2d_scrollers_draw(C, v2d, scrollers);
-       UI_view2d_scrollers_free(scrollers);
+       /* no scrollers here */
 }
 
 
index fb438ae45fba56c4163058bfc93b60d0d1992096..08f01b47b52b4f3c524b9bd25e388df7494f8b5e 100644 (file)
@@ -321,8 +321,7 @@ void file_calc_previews(const bContext *C, ARegion *ar)
        View2D *v2d = &ar->v2d;
        
        ED_fileselect_init_layout(sfile, ar);
-       /* +SCROLL_HEIGHT is bad hack to work around issue in UI_view2d_totRect_set */
-       UI_view2d_totRect_set(v2d, sfile->layout->width, sfile->layout->height + V2D_SCROLL_HEIGHT);
+       UI_view2d_totRect_set(v2d, sfile->layout->width, sfile->layout->height);
 }
 
 static void file_draw_preview(uiBlock *block, struct direntry *file, int sx, int sy, ImBuf *imb, FileLayout *layout, short dropshadow)
index fa7c6bd472a7311121b0360f375d3410eff1903c..734c0e6c479fec6ccb08cdfa89511f72ba83331e 100644 (file)
@@ -309,6 +309,12 @@ static void graph_channel_area_init(wmWindowManager *wm, ARegion *ar)
 {
        wmKeyMap *keymap;
        
+       /* make sure we keep the hide flags */
+       ar->v2d.scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
+       ar->v2d.scroll &= ~(V2D_SCROLL_LEFT | V2D_SCROLL_TOP);  /* prevent any noise of past */
+       ar->v2d.scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
+       ar->v2d.scroll |= V2D_SCROLL_VERTICAL_HIDE;
+       
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_LIST, ar->winx, ar->winy);
        
        /* own keymap */
index 222dcac454fe79f1a6bfef25fdb78f6b414e0aa5..1a058104c78a947ba798d22f10215726661ae46f 100644 (file)
@@ -421,17 +421,17 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                
                                uiBlockSetEmboss(block, UI_EMBOSSN);
                                bt = uiDefIconButR(block, ICONTOG, 0, ICON_RESTRICT_VIEW_OFF,
-                                                  (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                  (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                   &ptr, "hide", -1, 0, 0, -1, -1, NULL);
                                uiButSetFunc(bt, restrictbutton_view_cb, scene, ob);
                                
                                bt = uiDefIconButR(block, ICONTOG, 0, ICON_RESTRICT_SELECT_OFF,
-                                                  (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                  (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                   &ptr, "hide_select", -1, 0, 0, -1, -1, NULL);
                                uiButSetFunc(bt, restrictbutton_sel_cb, scene, ob);
                                
                                bt = uiDefIconButR(block, ICONTOG, 0, ICON_RESTRICT_RENDER_OFF,
-                                                  (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                  (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                   &ptr, "hide_render", -1, 0, 0, -1, -1, NULL);
                                uiButSetFunc(bt, restrictbutton_rend_cb, scene, ob);
                                
@@ -446,19 +446,19 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
 
                                restrict_bool = group_restrict_flag(gr, OB_RESTRICT_VIEW);
                                bt = uiDefIconBut(block, ICONTOG, 0, restrict_bool ? ICON_RESTRICT_VIEW_ON : ICON_RESTRICT_VIEW_OFF,
-                                                 (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                  NULL, 0, 0, 0, 0, "Restrict/Allow visibility in the 3D View");
                                uiButSetFunc(bt, restrictbutton_gr_restrict_view, scene, gr);
 
                                restrict_bool = group_restrict_flag(gr, OB_RESTRICT_SELECT);
                                bt = uiDefIconBut(block, ICONTOG, 0, restrict_bool ? ICON_RESTRICT_SELECT_ON : ICON_RESTRICT_SELECT_OFF,
-                                                 (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                  NULL, 0, 0, 0, 0, "Restrict/Allow selection in the 3D View");
                                uiButSetFunc(bt, restrictbutton_gr_restrict_select, scene, gr);
 
                                restrict_bool = group_restrict_flag(gr, OB_RESTRICT_RENDER);
                                bt = uiDefIconBut(block, ICONTOG, 0, restrict_bool ? ICON_RESTRICT_RENDER_ON : ICON_RESTRICT_RENDER_OFF,
-                                                 (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                  NULL, 0, 0, 0, 0, "Restrict/Allow renderability");
                                uiButSetFunc(bt, restrictbutton_gr_restrict_render, scene, gr);
 
@@ -469,7 +469,7 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                uiBlockSetEmboss(block, UI_EMBOSSN);
                                
                                bt = uiDefIconButBitI(block, ICONTOGN, SCE_LAY_DISABLE, 0, ICON_CHECKBOX_HLT - 1,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      te->directdata, 0, 0, 0, 0, "Render this RenderLayer");
                                uiButSetFunc(bt, restrictbutton_r_lay_cb, tselem->id, NULL);
                                
@@ -483,7 +483,7 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                
                                
                                bt = uiDefIconButBitI(block, ICONTOG, passflag, 0, ICON_CHECKBOX_HLT - 1,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      layflag, 0, 0, 0, 0, "Render this Pass");
                                uiButSetFunc(bt, restrictbutton_r_lay_cb, tselem->id, NULL);
                                
@@ -492,7 +492,7 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                          SCE_PASS_INDIRECT, SCE_PASS_EMIT, SCE_PASS_ENVIRONMENT))
                                {
                                        bt = uiDefIconButBitI(block, TOG, passflag, 0, (*layflag & passflag) ? ICON_DOT : ICON_BLANK1,
-                                                             (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                             (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                              layflag, 0, 0, 0, 0, "Exclude this Pass from Combined");
                                }
                                uiButSetFunc(bt, restrictbutton_r_lay_cb, tselem->id, NULL);
@@ -505,12 +505,12 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                
                                uiBlockSetEmboss(block, UI_EMBOSSN);
                                bt = uiDefIconButBitI(block, ICONTOGN, eModifierMode_Realtime, 0, ICON_RESTRICT_VIEW_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(md->mode), 0, 0, 0, 0, "Restrict/Allow visibility in the 3D View");
                                uiButSetFunc(bt, restrictbutton_modifier_cb, scene, ob);
                                
                                bt = uiDefIconButBitI(block, ICONTOGN, eModifierMode_Render, 0, ICON_RESTRICT_RENDER_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(md->mode), 0, 0, 0, 0, "Restrict/Allow renderability");
                                uiButSetFunc(bt, restrictbutton_modifier_cb, scene, ob);
                        }
@@ -520,12 +520,12 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                
                                uiBlockSetEmboss(block, UI_EMBOSSN);
                                bt = uiDefIconButBitI(block, ICONTOG, BONE_HIDDEN_P, 0, ICON_RESTRICT_VIEW_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(bone->flag), 0, 0, 0, 0, "Restrict/Allow visibility in the 3D View");
                                uiButSetFunc(bt, restrictbutton_bone_cb, NULL, bone);
                                
                                bt = uiDefIconButBitI(block, ICONTOG, BONE_UNSELECTABLE, 0, ICON_RESTRICT_SELECT_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(bone->flag), 0, 0, 0, 0, "Restrict/Allow selection in the 3D View");
                                uiButSetFunc(bt, restrictbutton_bone_cb, NULL, NULL);
                        }
@@ -534,12 +534,12 @@ static void outliner_draw_restrictbuts(uiBlock *block, Scene *scene, ARegion *ar
                                
                                uiBlockSetEmboss(block, UI_EMBOSSN);
                                bt = uiDefIconButBitI(block, ICONTOG, BONE_HIDDEN_A, 0, ICON_RESTRICT_VIEW_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(ebone->flag), 0, 0, 0, 0, "Restrict/Allow visibility in the 3D View");
                                uiButSetFunc(bt, restrictbutton_ebone_cb, NULL, ebone);
                                
                                bt = uiDefIconButBitI(block, ICONTOG, BONE_UNSELECTABLE, 0, ICON_RESTRICT_SELECT_OFF,
-                                                     (int)ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX, (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
+                                                     (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX), (int)te->ys, UI_UNIT_X, UI_UNIT_Y,
                                                      &(ebone->flag), 0, 0, 0, 0, "Restrict/Allow selection in the 3D View");
                                uiButSetFunc(bt, restrictbutton_ebone_cb, NULL, NULL);
                        }
@@ -553,7 +553,7 @@ static void outliner_draw_rnacols(ARegion *ar, int sizex)
 {
        View2D *v2d = &ar->v2d;
 
-       float miny = v2d->cur.ymin - V2D_SCROLL_HEIGHT;
+       float miny = v2d->cur.ymin;
        if (miny < v2d->tot.ymin) miny = v2d->tot.ymin;
 
        UI_ThemeColorShadeAlpha(TH_BACK, -15, -200);
@@ -850,7 +850,7 @@ static void outliner_draw_keymapbuts(uiBlock *block, ARegion *ar, SpaceOops *soo
                                
                                /* rna property */
                                if (kmi->ptr && kmi->ptr->data) {
-                                       uiDefBut(block, LABEL, 0, "(RNA property)", xstart, (int)te->ys + 1, butw2, UI_UNIT_Y - 1, &kmi->oskey, 0, 0, 0, 0, ""); xstart += butw2;
+                                       uiDefBut(block, LABEL, 0, "(RNA property)", xstart, (int)te->ys + 1, butw2, UI_UNIT_Y - 1, NULL, 0, 0, 0, 0, ""); xstart += butw2;
                                }
 
                                (void)xstart;
@@ -1533,13 +1533,13 @@ static void outliner_draw_struct_marks(ARegion *ar, SpaceOops *soops, ListBase *
                /* selection status */
                if (TSELEM_OPEN(tselem, soops))
                        if (tselem->type == TSE_RNA_STRUCT)
-                               glRecti(0, *starty + 1, (int)ar->v2d.cur.xmax + V2D_SCROLL_WIDTH, *starty + UI_UNIT_Y - 1);
+                               glRecti(0, *starty + 1, (int)ar->v2d.cur.xmax, *starty + UI_UNIT_Y - 1);
 
                *starty -= UI_UNIT_Y;
                if (TSELEM_OPEN(tselem, soops)) {
                        outliner_draw_struct_marks(ar, soops, &te->subtree, starty);
                        if (tselem->type == TSE_RNA_STRUCT)
-                               fdrawline(0, (float)*starty + UI_UNIT_Y, ar->v2d.cur.xmax + V2D_SCROLL_WIDTH, (float)*starty + UI_UNIT_Y);
+                               fdrawline(0, (float)*starty + UI_UNIT_Y, ar->v2d.cur.xmax, (float)*starty + UI_UNIT_Y);
                }
        }
 }
@@ -1608,7 +1608,7 @@ static void outliner_back(ARegion *ar)
        ystart = UI_UNIT_Y * (ystart / (UI_UNIT_Y)) - OL_Y_OFFSET;
        
        while (ystart + 2 * UI_UNIT_Y > ar->v2d.cur.ymin) {
-               glRecti(0, ystart, (int)ar->v2d.cur.xmax + V2D_SCROLL_WIDTH, ystart + UI_UNIT_Y);
+               glRecti(0, ystart, (int)ar->v2d.cur.xmax, ystart + UI_UNIT_Y);
                ystart -= 2 * UI_UNIT_Y;
        }
 }
@@ -1619,10 +1619,8 @@ static void outliner_draw_restrictcols(ARegion *ar)
        
        /* background underneath */
        UI_ThemeColor(TH_BACK);
-       glRecti((int)ar->v2d.cur.xmax - OL_TOGW,
-               (int)ar->v2d.cur.ymin - V2D_SCROLL_HEIGHT - 1,
-               (int)ar->v2d.cur.xmax + V2D_SCROLL_WIDTH,
-               (int)ar->v2d.cur.ymax);
+       glRecti((int)(ar->v2d.cur.xmax - OL_TOGW),
+               (int)(ar->v2d.cur.ymin - 1), (int)ar->v2d.cur.xmax, (int)ar->v2d.cur.ymax);
        
        UI_ThemeColorShade(TH_BACK, 6);
        ystart = (int)ar->v2d.tot.ymax;
@@ -1636,22 +1634,22 @@ static void outliner_draw_restrictcols(ARegion *ar)
        UI_ThemeColorShadeAlpha(TH_BACK, -15, -200);
 
        /* view */
-       fdrawline(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX,
-                 ar->v2d.cur.ymax,
-                 ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX,
-                 ar->v2d.cur.ymin - V2D_SCROLL_HEIGHT);
+       sdrawline((int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX),
+                 (int)ar->v2d.cur.ymax,
+                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_VIEWX),
+                 (int)ar->v2d.cur.ymin);
 
        /* render */
-       fdrawline(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX,
-                 ar->v2d.cur.ymax,
-                 ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX,
-                 ar->v2d.cur.ymin - V2D_SCROLL_HEIGHT);
+       sdrawline((int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX),
+                 (int)ar->v2d.cur.ymax,
+                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_SELECTX),
+                 (int)ar->v2d.cur.ymin);
 
        /* render */
-       fdrawline(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX,
-                 ar->v2d.cur.ymax,
-                 ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX,
-                 ar->v2d.cur.ymin - V2D_SCROLL_HEIGHT);
+       sdrawline((int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX),
+                 (int)ar->v2d.cur.ymax,
+                 (int)(ar->v2d.cur.xmax - OL_TOG_RESTRICT_RENDERX),
+                 (int)ar->v2d.cur.ymin);
 }
 
 /* ****************************************************** */
@@ -1700,11 +1698,9 @@ void draw_outliner(const bContext *C)
                // XXX this isn't that great yet...
                if ((soops->flag & SO_HIDE_RESTRICTCOLS) == 0)
                        sizex += OL_TOGW * 3;
+               
        }
        
-       /* tweak to display last line (when list bigger than window) */
-       sizey += V2D_SCROLL_HEIGHT;
-       
        /* adds vertical offset */
        sizey += OL_Y_OFFSET;
 
index f9fca378568a4f99908da225a55779eac66b23ce..63452de18d057cb881bf3becdf2e1eeb602b3639 100644 (file)
@@ -116,8 +116,8 @@ typedef struct TreeElement {
 /* size constants */
 #define OL_Y_OFFSET 2
 
-#define OL_TOG_RESTRICT_VIEWX   (UI_UNIT_X * 3)
-#define OL_TOG_RESTRICT_SELECTX (UI_UNIT_X * 2)
+#define OL_TOG_RESTRICT_VIEWX   (UI_UNIT_X * 3.0f)
+#define OL_TOG_RESTRICT_SELECTX (UI_UNIT_X * 2.0f)
 #define OL_TOG_RESTRICT_RENDERX UI_UNIT_X
 
 #define OL_TOGW OL_TOG_RESTRICT_VIEWX
index ecc09a356707aa8d31c367acba417d4a51967879..4bf88376b74a14081742e8819960bb1cd2a3411e 100644 (file)
@@ -67,6 +67,17 @@ static void outliner_main_area_init(wmWindowManager *wm, ARegion *ar)
        ListBase *lb;
        wmKeyMap *keymap;
        
+       /* make sure we keep the hide flags */
+       ar->v2d.scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
+       ar->v2d.scroll &= ~(V2D_SCROLL_LEFT | V2D_SCROLL_TOP);  /* prevent any noise of past */
+       ar->v2d.scroll |= V2D_SCROLL_HORIZONTAL_HIDE;
+       ar->v2d.scroll |= V2D_SCROLL_VERTICAL_HIDE;
+
+       ar->v2d.align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
+       ar->v2d.keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
+       ar->v2d.keeptot = V2D_KEEPTOT_STRICT;
+       ar->v2d.minzoom = ar->v2d.maxzoom = 1.0f;
+
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_LIST, ar->winx, ar->winy);
        
        /* own keymap */
@@ -410,12 +421,6 @@ static SpaceLink *outliner_new(const bContext *UNUSED(C))
        BLI_addtail(&soutliner->regionbase, ar);
        ar->regiontype = RGN_TYPE_WINDOW;
        
-       ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM_O);
-       ar->v2d.align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
-       ar->v2d.keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
-       ar->v2d.keeptot = V2D_KEEPTOT_STRICT;
-       ar->v2d.minzoom = ar->v2d.maxzoom = 1.0f;
-       
        return (SpaceLink *)soutliner;
 }
 
index 1ea3876f5cc1e84eadeac2f080bfe8410833a9ce..6560f218002d7b4d638f63ef308879a77a6d7d96 100644 (file)
@@ -105,14 +105,14 @@ static SpaceLink *userpref_duplicate(SpaceLink *sl)
 /* add handlers, stuff you only do once or on area/region changes */
 static void userpref_main_area_init(wmWindowManager *wm, ARegion *ar)
 {
+       ar->v2d.flag &= ~V2D_IS_INITIALISED;
+       ar->v2d.scroll = V2D_SCROLL_RIGHT | V2D_SCROLL_VERTICAL_HIDE;
+
        ED_region_panels_init(wm, ar);
 }
 
 static void userpref_main_area_draw(const bContext *C, ARegion *ar)
 {
-       /* this solves "vibrating UI" bug #25422 */
-       UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_PANELS_UI, ar->winx, ar->winy);
-       
        ED_region_panels(C, ar, 1, NULL, -1);
 }
 
index 084496871bfc5ef1c1b7c9051ac42da3e6b5908b..a7921be44d54a2416271bf0ffef395fa06411b31 100644 (file)
@@ -123,9 +123,9 @@ typedef struct View2D {
        /* horizontal scrollbar */
 #define V2D_SCROLL_TOP                                 (1<<2)
 #define V2D_SCROLL_BOTTOM                      (1<<3)
-       /* special hack for outliner hscroll - prevent hanging older versions of Blender */
-#define V2D_SCROLL_BOTTOM_O            (1<<4)
-#define V2D_SCROLL_HORIZONTAL                  (V2D_SCROLL_TOP|V2D_SCROLL_BOTTOM|V2D_SCROLL_BOTTOM_O)
+
+/* UNUSED                                                      (1<<4) */
+#define V2D_SCROLL_HORIZONTAL                  (V2D_SCROLL_TOP|V2D_SCROLL_BOTTOM)
        /* scale markings - vertical */
 #define V2D_SCROLL_SCALE_VERTICAL      (1<<5)
        /* scale markings - horizontal */
index be202a23d334bbf9aa45ed217f58a25a878a267e..ec94501c8bec2710005691deffcdd7cb491ca28d 100644 (file)
@@ -544,6 +544,7 @@ void WM_window_open_temp(bContext *C, rcti *position, int type)
        }
        
        ED_screen_set(C, win->screen);
+       ED_screen_refresh(CTX_wm_manager(C), win); /* test scale */
        
        if (sa->spacetype == SPACE_IMAGE)
                GHOST_SetTitle(win->ghostwin, IFACE_("Blender Render"));