dont use tface hide or select anymore, since maintaining 2 sets of hide/select data...
[blender.git] / source / blender / src / drawimage.c
index cafaf8efa66d5a546da770da762f3c5330595bf6..188f48bcdca1adb96d2255590b02a4b291b20eb7 100644 (file)
@@ -1,15 +1,12 @@
 /**
  * $Id$
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,9 +22,9 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Blender Foundation, 2002-2006
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
 #include <math.h>
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
+#include "DNA_brush_types.h"
 #include "DNA_camera_types.h"
 #include "DNA_color_types.h"
 #include "DNA_image_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
+#include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_packedFile_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
+#include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 
+#include "BKE_brush.h"
 #include "BKE_colortools.h"
 #include "BKE_utildefines.h"
 #include "BKE_global.h"
@@ -79,7 +80,9 @@
 #include "BDR_drawmesh.h"
 #include "BDR_imagepaint.h"
 
+#include "BIF_cursors.h"
 #include "BIF_gl.h"
+#include "BIF_graphics.h"
 #include "BIF_mywindow.h"
 #include "BIF_drawimage.h"
 #include "BIF_resources.h"
 #include "BIF_renderwin.h"
 #include "BIF_space.h"
 #include "BIF_screen.h"
+#include "BIF_toolbox.h"
 #include "BIF_transform.h"
 
 #include "BSE_drawipo.h"
+#include "BSE_drawview.h"
+#include "BSE_filesel.h"
 #include "BSE_headerbuttons.h"
+#include "BSE_node.h"
 #include "BSE_trans_types.h"
 #include "BSE_view.h"
 
 #include "mydevice.h"
 #include "blendef.h"
 #include "butspace.h"  // event codes
+#include "winlay.h"
 
 #include "interface.h" /* bad.... but preview code needs UI info. Will solve... (ton) */
 
 static unsigned char *alloc_alpha_clone_image(int *width, int *height)
 {
+       Brush *brush = G.scene->toolsettings->imapaint.brush;
+       ImBuf *ibuf;
        unsigned int size, alpha;
        unsigned char *rect, *cp;
 
-       if(!Gip.clone.image)
+       if(!brush || !brush->clone.image)
                return NULL;
+       
+       ibuf= BKE_image_get_ibuf(brush->clone.image, NULL);
 
-       if(!Gip.clone.image->ibuf)
-               load_image(Gip.clone.image, IB_rect, G.sce, G.scene->r.cfra);
-
-       if(!Gip.clone.image->ibuf || !Gip.clone.image->ibuf->rect)
+       if(!ibuf || !ibuf->rect)
                return NULL;
 
-       rect= MEM_dupallocN(Gip.clone.image->ibuf->rect);
-
+       rect= MEM_dupallocN(ibuf->rect);
        if(!rect)
                return NULL;
 
-       *width= Gip.clone.image->ibuf->x;
-       *height= Gip.clone.image->ibuf->y;
+       *width= ibuf->x;
+       *height= ibuf->y;
 
        size= (*width)*(*height);
-       alpha= (unsigned char)255*Gip.clone.alpha;
+       alpha= (unsigned char)255*brush->clone.alpha;
        cp= rect;
 
        while(size-- > 0) {
@@ -141,24 +149,12 @@ static unsigned char *alloc_alpha_clone_image(int *width, int *height)
        return rect;
 }
 
-static void setcloneimage()
-{
-       if(G.sima->menunr > 0) {
-               Image *ima= (Image*)BLI_findlink(&G.main->image, G.sima->menunr-1);
-
-               if(ima) {
-                       Gip.clone.image= ima;
-                       Gip.clone.offset[0]= Gip.clone.offset[0]= 0.0;
-               }
-       }
-}
-
 static int image_preview_active(ScrArea *sa, float *xim, float *yim)
 {
        SpaceImage *sima= sa->spacedata.first;
        
        /* only when compositor shows, and image handler set */
-       if(sima->image == (Image *)find_id("IM", "Compositor")) {
+       if(sima->image && sima->image->type==IMA_TYPE_COMPOSITE) {
                short a;
        
                for(a=0; a<SPACE_MAXHANDLER; a+=2) {
@@ -192,11 +188,13 @@ void calc_image_view(SpaceImage *sima, char mode)
        
        if(image_preview_active(curarea, &xim, &yim));
        else if(sima->image) {
-               if(sima->image->ibuf) {
-                       xim= sima->image->ibuf->x;
-                       yim= sima->image->ibuf->y;
+               ImBuf *ibuf= BKE_image_get_ibuf(sima->image, &sima->iuser);
+               
+               if(ibuf) {
+                       xim= ibuf->x;
+                       yim= ibuf->y;
                }
-               else if( BLI_streq(sima->image->name, "Render Result") ) {
+               else if( sima->image->type==IMA_TYPE_R_RESULT ) {
                        /* not very important, just nice */
                        xim= (G.scene->r.xsch*G.scene->r.size)/100;
                        yim= (G.scene->r.ysch*G.scene->r.size)/100;
@@ -243,34 +241,20 @@ void calc_image_view(SpaceImage *sima, char mode)
 /* check for facelesect, and set active image */
 void what_image(SpaceImage *sima)
 {
-       TFace *activetf;
+       MTFace *activetf;
        Mesh *me;
                
        if(sima->mode==SI_TEXTURE) {
                
-               if(sima->image && BLI_streq(sima->image->name, "Render Result")) {
-                       if(sima->image->ibuf==NULL) {
-                               RenderResult rres;
-                               
-                               /* make ibuf if needed, and initialize it */
-                               RE_GetResultImage(RE_GetRender(G.scene->id.name), &rres);
-                               if(rres.rectf || rres.rect32) {
-                                       ImBuf *ibuf= sima->image->ibuf= IMB_allocImBuf(rres.rectx, rres.recty, 32, 0, 0);
-                                       
-                                       ibuf->x= rres.rectx;
-                                       ibuf->y= rres.recty;
-                                       ibuf->rect= rres.rect32;
-                                       ibuf->rect_float= rres.rectf;
-                               }
-                       }
-               }
+               /* viewer overrides faceselect */
+               if(sima->image && sima->image->source==IMA_SRC_VIEWER);
                else if((G.f & G_FACESELECT)) {
                        
                        sima->image= NULL;
                        me= get_mesh(OBACT);
-                       activetf = get_active_tface();
+                       activetf = get_active_tface(NULL);
                        
-                       if(me && me->tface && activetf && activetf->mode & TF_TEX) {
+                       if(me && me->mtface && activetf && activetf->mode & TF_TEX) {
                                sima->image= activetf->tpage;
                                
                                if(sima->flag & SI_EDITTILE);
@@ -287,21 +271,52 @@ void what_image(SpaceImage *sima)
        }
 }
 
+/* after a what_image(), this call will give ibufs, includes the spare image */
+ImBuf *imagewindow_get_ibuf(SpaceImage *sima)
+{
+       
+       if(G.sima->image) {
+               /* check for spare */
+               if(sima->image->type==IMA_TYPE_R_RESULT && sima->showspare)
+                       return sima->spare;
+               else
+                       return BKE_image_get_ibuf(sima->image, &sima->iuser);
+       }
+       return NULL;
+}
+
+
+/* called to assign images to UV faces */
 void image_changed(SpaceImage *sima, int dotile)
 {
-       TFace *tface;
+       MTFace *tface;
+       MFace *mface;
        Mesh *me;
        int a;
+
+       if(sima->image==NULL)
+               sima->flag &= ~SI_DRAWTOOL;
        
        if(sima->mode==SI_TEXTURE) {
                
                if(G.f & G_FACESELECT) {
+                       
+                       /* skip assigning these procedural images... */
+                       if(sima->image) {
+                               if(sima->image->type==IMA_TYPE_R_RESULT)
+                                       return;
+                               if(sima->image->type==IMA_TYPE_COMPOSITE)
+                                       return;
+                       }
+                       
                        me= get_mesh(OBACT);
-                       if(me && me->tface) {
-                               tface= me->tface;
+                       if(me && me->mtface) {
+                               
+                               tface= me->mtface;
+                               mface = me->mface;
                                a= me->totface;
                                while(a--) {
-                                       if(tface->flag & TF_SELECT) {
+                                       if(mface->flag & ME_FACE_SEL) {
                                                
                                                if(dotile==2) {
                                                        tface->mode &= ~TF_TILES;
@@ -317,10 +332,12 @@ void image_changed(SpaceImage *sima, int dotile)
                                                        if(sima->image->tpageflag & IMA_TILES) tface->mode |= TF_TILES;
                                                        else tface->mode &= ~TF_TILES;
                                                
-                                                       if(sima->image->id.us==0) sima->image->id.us= 1;
+                                                       if(sima->image->id.us==0) id_us_plus(&sima->image->id);
+                                                       else id_lib_extern(&sima->image->id);
                                                }
                                        }
                                        tface++;
+                                       mface++;
                                }
 
                                object_uvs_changed(OBACT);
@@ -366,7 +383,7 @@ void uvco_to_areaco_noclip(float *vec, int *mval)
 
 void draw_tfaces(void)
 {
-       TFace *tface,*activetface = NULL;
+       MTFace *tface,*activetface = NULL;
        MFace *mface,*activemface = NULL;
        Mesh *me;
        int a;
@@ -374,40 +391,60 @@ void draw_tfaces(void)
        float pointsize= BIF_GetThemeValuef(TH_VERTEX_SIZE);
        
        if(G.f & G_FACESELECT) {
-               me= get_mesh((G.scene->basact) ? (G.scene->basact->object) : 0);
-               if(me && me->tface) {
+               me= get_mesh(OBACT);
+
+               if(me && me->mtface) {
                        calc_image_view(G.sima, 'f');   /* float */
                        myortho2(G.v2d->cur.xmin, G.v2d->cur.xmax, G.v2d->cur.ymin, G.v2d->cur.ymax);
                        glLoadIdentity();
                        
                        /* draw shadow mesh */
-                       if((G.sima->flag & SI_DRAWSHADOW) && !(G.obedit==OBACT)){
-                               int dmNeedsFree;
-                               DerivedMesh *dm = mesh_get_derived_final(OBACT, &dmNeedsFree);
+                       if ((G.sima->flag & SI_DRAWSHADOW) && !(G.obedit==OBACT)) {
+                               DerivedMesh *dm;
+
+                               /* draw final mesh with modifiers applied */
+                               dm = mesh_get_derived_final(OBACT,
+                                                           CD_MASK_BAREMESH | CD_MASK_MTFACE);
 
                                glColor3ub(112, 112, 112);
                                if (dm->drawUVEdges) dm->drawUVEdges(dm);
 
-                               if (dmNeedsFree) dm->release(dm);
+                               dm->release(dm);
                        }
-                       else if(G.sima->flag & SI_DRAWSHADOW){          
-                               tface= me->tface;
-                               mface= me->mface;
-                               a= me->totface;                 
-                               while(a--) {
-                                       if(!(tface->flag & TF_HIDE)) {
-                                               glColor3ub(112, 112, 112);
-                                               glBegin(GL_LINE_LOOP);
-                                               glVertex2fv(tface->uv[0]);
-                                               glVertex2fv(tface->uv[1]);
-                                               glVertex2fv(tface->uv[2]);
-                                               if(mface->v4) glVertex2fv(tface->uv[3]);
-                                               glEnd();
-                                       } 
-                                       tface++;
-                                       mface++;                                        
+                       else if((G.sima->flag & SI_DRAWTOOL) || (G.obedit==OBACT)) {
+                               /* draw mesh without modifiers applied */
+
+                               if (G.obedit) {
+                                       DerivedMesh *dm = editmesh_get_derived_base();
+
+                                       glColor3ub(112, 112, 112);
+                                       dm->drawUVEdges(dm);
+
+                                       dm->release(dm);
+                               }
+                               else {
+                                       tface= me->mtface;
+                                       mface= me->mface;
+                                       a= me->totface;                 
+
+                                       glColor3ub(112, 112, 112);
+                                       while(a--) {
+                                               if(!(mface->flag & ME_HIDE) && (mface->flag & ME_FACE_SEL)) {
+                                                       glBegin(GL_LINE_LOOP);
+                                                       glVertex2fv(tface->uv[0]);
+                                                       glVertex2fv(tface->uv[1]);
+                                                       glVertex2fv(tface->uv[2]);
+                                                       if(mface->v4) glVertex2fv(tface->uv[3]);
+                                                       glEnd();
+                                               } 
+                                               tface++;
+                                               mface++;                                        
+                                       }
                                }
                        }
+
+                       if((G.sima->flag & SI_DRAWTOOL) || (G.obedit==OBACT))
+                               return; /* only draw shadow mesh */
                        
                        /* draw transparent faces */
                        if(G.f & G_DRAWFACES) {
@@ -415,16 +452,16 @@ void draw_tfaces(void)
                                BIF_GetThemeColor4ubv(TH_FACE_SELECT, col2);
                                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                                glEnable(GL_BLEND);
-                               tface= me->tface;
+                               tface= me->mtface;
                                mface= me->mface;
                                a= me->totface;                 
                                while(a--) {
-                                       if(tface->flag & TF_SELECT) {
+                                       if(mface->flag & ME_FACE_SEL) {
                                                if(!(~tface->flag & (TF_SEL1|TF_SEL2|TF_SEL3)) &&
                                                   (!mface->v4 || tface->flag & TF_SEL4))
-                                                       glColor4ubv(col2);
+                                                       glColor4ubv((GLubyte *)col2);
                                                else
-                                                       glColor4ubv(col1);
+                                                       glColor4ubv((GLubyte *)col1);
                                                        
                                                glBegin(mface->v4?GL_QUADS:GL_TRIANGLES);
                                                        glVertex2fv(tface->uv[0]);
@@ -440,11 +477,11 @@ void draw_tfaces(void)
                        }
 
 
-                       tface= me->tface;
+                       tface= me->mtface;
                        mface= me->mface;
                        a= me->totface;
                        while(a--) {
-                               if(tface->flag & TF_SELECT) {
+                               if(mface->flag & ME_FACE_SEL) {
                                        if(tface->flag & TF_ACTIVE){
                                                activetface= tface; 
                                                activemface= mface; 
@@ -527,11 +564,11 @@ void draw_tfaces(void)
                        glPointSize(pointsize);
 
                        bglBegin(GL_POINTS);
-                       tface= me->tface;
+                       tface= me->mtface;
                        mface= me->mface;
                        a= me->totface;
                        while(a--) {
-                               if(tface->flag & TF_SELECT) {
+                               if(mface->flag & ME_FACE_SEL) {
                                        
                                        if(tface->flag & TF_SEL1); else bglVertex2fv(tface->uv[0]);
                                        if(tface->flag & TF_SEL2); else bglVertex2fv(tface->uv[1]);
@@ -551,11 +588,11 @@ void draw_tfaces(void)
                        cpack(0xFF);
 
                        bglBegin(GL_POINTS);
-                       tface= me->tface;
+                       tface= me->mtface;
                        mface= me->mface;
                        a= me->totface;
                        while(a--) {
-                               if(tface->flag & TF_SELECT) {
+                               if(mface->flag & ME_FACE_SEL) {
                                        
                                        if(tface->unwrap & TF_PIN1) bglVertex2fv(tface->uv[0]);
                                        if(tface->unwrap & TF_PIN2) bglVertex2fv(tface->uv[1]);
@@ -574,11 +611,11 @@ void draw_tfaces(void)
                glPointSize(pointsize);
 
                        bglBegin(GL_POINTS);
-                       tface= me->tface;
+                       tface= me->mtface;
                        mface= me->mface;
                        a= me->totface;
                        while(a--) {
-                               if(tface->flag & TF_SELECT) {
+                               if(mface->flag & ME_FACE_SEL) {
                                        
                                        if(tface->flag & TF_SEL1) bglVertex2fv(tface->uv[0]);
                                        if(tface->flag & TF_SEL2) bglVertex2fv(tface->uv[1]);
@@ -591,9 +628,11 @@ void draw_tfaces(void)
                                mface++;
                        }
                        bglEnd();
+
+                       glPointSize(1.0);
                }
        }
-       glPointSize(1.0);
+       
 }
 
 static unsigned int *get_part_from_ibuf(ImBuf *ibuf, short startx, short starty, short endx, short endy)
@@ -655,16 +694,16 @@ static void draw_image_view_icon(void)
        glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA); 
        
        if(G.sima->flag & SI_STICKYUVS) {
-               BIF_icon_draw(xPos, 5.0, ICON_STICKY2_UVS);
+               BIF_icon_draw_aspect(xPos, 5.0, ICON_STICKY2_UVS, 1.0f);
                xPos = 25.0;
        }
        else if(!(G.sima->flag & SI_LOCALSTICKY)) {
-               BIF_icon_draw(xPos, 5.0, ICON_STICKY_UVS);
+               BIF_icon_draw_aspect(xPos, 5.0, ICON_STICKY_UVS, 1.0f);
                xPos = 25.0;
        }
 
        if(G.sima->flag & SI_SELACTFACE) {
-               BIF_icon_draw(xPos, 5.0, ICON_DRAW_UVFACES);
+               BIF_icon_draw_aspect(xPos, 5.0, ICON_DRAW_UVFACES, 1.0f);
        }
        
        glBlendFunc(GL_ONE,  GL_ZERO); 
@@ -673,59 +712,61 @@ static void draw_image_view_icon(void)
 
 static void draw_image_view_tool(void)
 {
-       ImagePaintTool *tool = &Gip.tool[Gip.current];
+       ToolSettings *settings= G.scene->toolsettings;
+       Brush *brush= settings->imapaint.brush;
        short mval[2];
        float radius;
        int draw= 0;
 
-       if(Gip.flag & IMAGEPAINT_DRAWING) {
-               if(Gip.flag & IMAGEPAINT_DRAW_TOOL_DRAWING)
+       if(brush) {
+               if(settings->imapaint.flag & IMAGEPAINT_DRAWING) {
+                       if(settings->imapaint.flag & IMAGEPAINT_DRAW_TOOL_DRAWING)
+                               draw= 1;
+               }
+               else if(settings->imapaint.flag & IMAGEPAINT_DRAW_TOOL)
                        draw= 1;
-       }
-       else if(Gip.flag & IMAGEPAINT_DRAW_TOOL)
-               draw= 1;
-       
-       if(draw) {
-               getmouseco_areawin(mval);
-
-               radius= tool->size*G.sima->zoom/2;
-               fdrawXORcirc(mval[0], mval[1], radius);
+               
+               if(draw) {
+                       getmouseco_areawin(mval);
 
-               if (tool->innerradius != 1.0) {
-                       radius *= tool->innerradius;
+                       radius= brush->size*G.sima->zoom/2;
                        fdrawXORcirc(mval[0], mval[1], radius);
+
+                       if (brush->innerradius != 1.0) {
+                               radius *= brush->innerradius;
+                               fdrawXORcirc(mval[0], mval[1], radius);
+                       }
                }
        }
 }
 
 /* ************ panel stuff ************* */
 
-// button define is local, only events defined here possible
-#define B_TRANS_IMAGE  1
-
 /* is used for both read and write... */
-static void image_editvertex_buts(uiBlock *block)
+void image_editvertex_buts(uiBlock *block)
 {
        static float ocent[2];
        float cent[2]= {0.0, 0.0};
-       int imx, imy;
+       int imx= 256, imy= 256;
        int i, nactive= 0, step, digits;
        Mesh *me;
        
        if( is_uv_tface_editing_allowed_silent()==0 ) return;
        me= get_mesh(OBACT);
        
-       if (G.sima->image && G.sima->image->ibuf) {
-               imx= G.sima->image->ibuf->x;
-               imy= G.sima->image->ibuf->y;
-       } else
-               imx= imy= 256;
+       if (G.sima->image) {
+               ImBuf *ibuf= imagewindow_get_ibuf(G.sima);
+               if(ibuf) {
+                       imx= ibuf->x;
+                       imy= ibuf->y;
+               }
+       }
        
        for (i=0; i<me->totface; i++) {
                MFace *mf= &((MFace*) me->mface)[i];
-               TFace *tf= &((TFace*) me->tface)[i];
+               MTFace *tf= &((MTFace*) me->mtface)[i];
                
-               if (!(tf->flag & TF_SELECT))
+               if (!(mf->flag & ME_FACE_SEL))
                        continue;
                
                if (tf->flag & TF_SEL1) {
@@ -765,7 +806,7 @@ static void image_editvertex_buts(uiBlock *block)
                                digits= 2;
                        }
                        
-                       uiDefBut(block, LABEL, 0, "UV Vertex:",10,55,302,19,0,0,0,0,0,"");
+                       uiDefBut(block, LABEL, 0, "UV Vertex:",10,55,300,19,0,0,0,0,0,"");
                        uiBlockBeginAlign(block);
                        if(nactive==1) {
                                uiDefButF(block, NUM, B_TRANS_IMAGE, "Vertex X:",       10, 35, 290, 19, &ocent[0], -10*imx, 10.0*imx, step, digits, "");
@@ -795,9 +836,9 @@ static void image_editvertex_buts(uiBlock *block)
 
                for (i=0; i<me->totface; i++) {
                        MFace *mf= &((MFace*) me->mface)[i];
-                       TFace *tf= &((TFace*) me->tface)[i];
+                       MTFace *tf= &((MTFace*) me->mtface)[i];
                
-                       if (!(tf->flag & TF_SELECT))
+                       if (!(mf->flag & ME_FACE_SEL))
                                continue;
                
                        if (tf->flag & TF_SEL1) {
@@ -823,93 +864,79 @@ static void image_editvertex_buts(uiBlock *block)
        }
 }
 
-
-void do_imagebuts(unsigned short event)
+void image_info(Image *ima, ImBuf *ibuf, char *str)
 {
-       switch(event) {
-       case B_TRANS_IMAGE:
-               image_editvertex_buts(NULL);
-               break;
-
-       case B_SIMAGEDRAW:
-               if(G.f & G_FACESELECT) {
-                       make_repbind(G.sima->image);
-                       image_changed(G.sima, 1);
-               }
-               allqueue(REDRAWVIEW3D, 0);
-               allqueue(REDRAWIMAGE, 0);
-               break;
+       int ofs= 0;
+       
+       str[0]= 0;
+       
+       if(ima==NULL) return;
+       if(ibuf==NULL) {
+               sprintf(str, "Can not get an image");
+               return;
+       }
+       
+       if(ima->source==IMA_SRC_MOVIE) {
+               ofs= sprintf(str, "Movie ");
+               if(ima->anim) 
+                       ofs+= sprintf(str+ofs, "%d frs", IMB_anim_get_duration(ima->anim));
+       }
+       else
+               ofs= sprintf(str, "Image ");
 
-       case B_SIMAGEDRAW1:
-               image_changed(G.sima, 2);               /* 2: only tileflag */
-               allqueue(REDRAWVIEW3D, 0);
-               allqueue(REDRAWIMAGE, 0);
-               break;
-               
-       case B_TWINANIM:
-               {
-                       Image *ima;
-                       int nr;
-
-                       ima = G.sima->image;
-                       if (ima) {
-                               if(ima->flag & IMA_TWINANIM) {
-                                       nr= ima->xrep*ima->yrep;
-                                       if(ima->twsta>=nr) ima->twsta= 1;
-                                       if(ima->twend>=nr) ima->twend= nr-1;
-                                       if(ima->twsta>ima->twend) ima->twsta= 1;
-                                       allqueue(REDRAWIMAGE, 0);
-                               }
-                       }
+       ofs+= sprintf(str+ofs, ": size %d x %d,", ibuf->x, ibuf->y);
+       
+       if(ibuf->rect_float) {
+               if(ibuf->channels!=4) {
+                       sprintf(str+ofs, "%d float channel(s)", ibuf->channels);
                }
-               break;
-
-       case B_SIMACLONEBROWSE:
-               setcloneimage();
-               allqueue(REDRAWIMAGE, 0);
-               break;
-               
-       case B_SIMACLONEDELETE:
-               Gip.clone.image= NULL;
-               allqueue(REDRAWIMAGE, 0);
-               break;
-
-       case B_SIMABRUSHCHANGE:
-               allqueue(REDRAWIMAGE, 0);
-               break;
-               
-       case B_SIMACURVES:
-               curvemapping_do_image(G.sima->cumap, G.sima->image);
-               allqueue(REDRAWIMAGE, 0);
-               break;
-               
-       case B_SIMARANGE:
-               curvemapping_set_black_white(G.sima->cumap, NULL, NULL);
-               curvemapping_do_image(G.sima->cumap, G.sima->image);
-               allqueue(REDRAWIMAGE, 0);
-               break;
+               else if(ibuf->depth==32)
+                       strcat(str, " RGBA float");
+               else
+                       strcat(str, " RGB float");
+       }
+       else {
+               if(ibuf->depth==32)
+                       strcat(str, " RGBA byte");
+               else
+                       strcat(str, " RGB byte");
        }
+       if(ibuf->zbuf || ibuf->zbuf_float)
+               strcat(str, " + Z");
+       
 }
 
 static void image_panel_properties(short cntrl)        // IMAGE_HANDLER_PROPERTIES
 {
        uiBlock *block;
-
+       
        block= uiNewBlock(&curarea->uiblocks, "image_panel_properties", UI_EMBOSS, UI_HELV, curarea->win);
        uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
        uiSetPanelHandler(IMAGE_HANDLER_PROPERTIES);  // for close and esc
        if(uiNewPanel(curarea, block, "Properties", "Image", 10, 10, 318, 204)==0)
                return;
+       
+       /* note, it draws no bottom half in facemode, for vertex buttons */
+       uiblock_image_panel(block, &G.sima->image, &G.sima->iuser, B_REDR, B_REDR);
 
-       if (G.sima->image && G.sima->image->ibuf) {
-               char str[64];
+       image_editvertex_buts(block);
+}      
 
-               sprintf(str, "Image: size %d x %d", G.sima->image->ibuf->x, G.sima->image->ibuf->y);
-               if(G.sima->image->ibuf->rect_float)
-                       strcat(str, " 4x32 bits");
-               else 
-                       strcat(str, " 4x8 bits");
+static void image_panel_game_properties(short cntrl)   // IMAGE_HANDLER_GAME_PROPERTIES
+{
+       ImBuf *ibuf= BKE_image_get_ibuf(G.sima->image, &G.sima->iuser);
+       uiBlock *block;
+
+       block= uiNewBlock(&curarea->uiblocks, "image_panel_game_properties", UI_EMBOSS, UI_HELV, curarea->win);
+       uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
+       uiSetPanelHandler(IMAGE_HANDLER_GAME_PROPERTIES);  // for close and esc
+       if(uiNewPanel(curarea, block, "Real-time Properties", "Image", 10, 10, 318, 204)==0)
+               return;
+
+       if (ibuf) {
+               char str[128];
                
+               image_info(G.sima->image, ibuf, str);
                uiDefBut(block, LABEL, B_NOP, str,              10,180,300,19, 0, 0, 0, 0, 0, "");
 
                uiBlockBeginAlign(block);
@@ -924,19 +951,24 @@ static void image_panel_properties(short cntrl)   // IMAGE_HANDLER_PROPERTIES
                uiDefButS(block, NUM, B_SIMAGEDRAW, "X:",               160,130,70,19, &G.sima->image->xrep, 1.0, 16.0, 0, 0, "Sets the degree of repetition in the X direction");
                uiDefButS(block, NUM, B_SIMAGEDRAW, "Y:",               230,130,70,19, &G.sima->image->yrep, 1.0, 16.0, 0, 0, "Sets the degree of repetition in the Y direction");
                uiBlockBeginAlign(block);
-       }
 
-       image_editvertex_buts(block);
+               uiBlockBeginAlign(block);
+               uiDefButBitS(block, TOG, IMA_CLAMP_U, B_SIMAGEDRAW, "ClampX",   160,100,70,19, &G.sima->image->tpageflag, 0, 0, 0, 0, "Disable texture repeating horizontaly");
+               uiDefButBitS(block, TOG, IMA_CLAMP_V, B_SIMAGEDRAW, "ClampY",   230,100,70,19, &G.sima->image->tpageflag, 0, 0, 0, 0, "Disable texture repeating vertically");
+               uiBlockEndAlign(block);         
+       }
 }
 
-static void image_panel_paint(short cntrl)     // IMAGE_HANDLER_PROPERTIES
+static void image_panel_paint(short cntrl)     // IMAGE_HANDLER_PAINT
 {
        /* B_SIMABRUSHCHANGE only redraws and eats the mouse messages  */
        /* so that LEFTMOUSE does not 'punch' through the floating panel */
        /* B_SIMANOTHING */
-       ImagePaintTool *tool= &Gip.tool[Gip.current];
+       ToolSettings *settings= G.scene->toolsettings;
+       Brush *brush= settings->imapaint.brush;
        uiBlock *block;
        ID *id;
+       int yco, xco, butw;
 
        block= uiNewBlock(&curarea->uiblocks, "image_panel_paint", UI_EMBOSS, UI_HELV, curarea->win);
        uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
@@ -944,42 +976,77 @@ static void image_panel_paint(short cntrl)        // IMAGE_HANDLER_PROPERTIES
        if(uiNewPanel(curarea, block, "Image Paint", "Image", 10, 230, 318, 204)==0)
                return;
 
-       uiBlockBeginAlign(block);
-       uiDefButF(block, COL, B_VPCOLSLI, "",           979,160,230,19, tool->rgba, 0, 0, 0, 0, "");
-       uiDefButF(block, NUMSLI, B_SIMANOTHING , "Opacity ",            979,140,230,19, tool->rgba+3, 0.0, 1.0, 0, 0, "The amount of pressure on the brush");
-       uiDefButI(block, NUMSLI, B_SIMANOTHING , "Size ",               979,120,230,19, &tool->size, 2, 64, 0, 0, "The size of the brush");
-       uiDefButF(block, NUMSLI, B_SIMANOTHING , "Fall ",               979,100,230,19, &tool->innerradius, 0.0, 1.0, 0, 0, "The fall off radius of the brush");
-
-       if(Gip.current == IMAGEPAINT_BRUSH || Gip.current == IMAGEPAINT_SMEAR)
-               uiDefButF(block, NUMSLI, B_SIMANOTHING , "Stepsize ",979,80,230,19, &tool->timing, 1.0, 100.0, 0, 0, "Repeating Paint On %of Brush diameter");
-       else
-               uiDefButF(block, NUMSLI, B_SIMANOTHING , "Flow ",       979,80,230,19, &tool->timing, 1.0, 100.0, 0, 0, "Paint Flow for Air Brush");
-       uiBlockEndAlign(block);
+       yco= 160;
 
        uiBlockBeginAlign(block);
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Brush",               890,160,80,19, &Gip.current, 7.0, IMAGEPAINT_BRUSH, 0, 0, "Brush");
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "AirBrush",            890,140,80,19, &Gip.current, 7.0, IMAGEPAINT_AIRBRUSH, 0, 0, "AirBrush");
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Soften",              890,120,80,19, &Gip.current, 7.0, IMAGEPAINT_SOFTEN, 0, 0, "Soften");
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Aux AB1",             890,100,80,19, &Gip.current, 7.0, IMAGEPAINT_AUX1, 0, 0, "Auxiliary Air Brush1");
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Aux AB2",             890,80,80,19, &Gip.current, 7.0, IMAGEPAINT_AUX2, 0, 0, "Auxiliary Air Brush2");        
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Smear",               890,60,80,19, &Gip.current, 7.0, IMAGEPAINT_SMEAR, 0, 0, "Smear");      
-       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Clone",               890,40,80,19, &Gip.current, 7.0, IMAGEPAINT_CLONE, 0, 0, "Clone Brush / use RMB to drag source image"); 
+       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Draw",                0  ,yco,80,19, &settings->imapaint.tool, 7.0, PAINT_TOOL_DRAW, 0, 0, "Draw brush");
+       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Soften",              80 ,yco,80,19, &settings->imapaint.tool, 7.0, PAINT_TOOL_SOFTEN, 0, 0, "Soften brush");
+       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Smear",               160,yco,80,19, &settings->imapaint.tool, 7.0, PAINT_TOOL_SMEAR, 0, 0, "Smear brush");   
+       uiDefButS(block, ROW, B_SIMABRUSHCHANGE, "Clone",               240,yco,80,19, &settings->imapaint.tool, 7.0, PAINT_TOOL_CLONE, 0, 0, "Clone brush, use RMB to drag source image");     
        uiBlockEndAlign(block);
+       yco -= 30;
 
-       uiBlockBeginAlign(block);       
-       id= (ID*)Gip.clone.image;
-       std_libbuttons(block, 979, 40, 0, NULL, B_SIMACLONEBROWSE, ID_IM, 0, id, 0, &G.sima->menunr, 0, 0, B_SIMACLONEDELETE, 0, 0);
-       uiDefButF(block, NUMSLI, B_SIMABRUSHCHANGE, "B ",979,20,230,19, &Gip.clone.alpha , 0.0, 1.0, 0, 0, "Blend clone image");
-       uiBlockEndAlign(block);
+       uiBlockSetCol(block, TH_BUT_SETTING2);
+       id= (ID*)settings->imapaint.brush;
+       xco= std_libbuttons(block, 0, yco, 0, NULL, B_SIMABRUSHBROWSE, ID_BR, 0, id, NULL, &(G.sima->menunr), 0, B_SIMABRUSHLOCAL, B_SIMABRUSHDELETE, 0, B_KEEPDATA);
+       uiBlockSetCol(block, TH_AUTO);
+
+       if(brush && !brush->id.lib) {
+               butw= 320-(xco+10);
+
+               uiDefButS(block, MENU, B_SIMANOTHING, "Mix %x0|Add %x1|Subtract %x2|Multiply %x3|Lighten %x4|Darken %x5|Erase Alpha %x6|Add Alpha %x7", xco+10,yco,butw,19, &brush->blend, 0, 0, 0, 0, "Blending method for applying brushes");
+
+               uiDefButBitS(block, TOG|BIT, BRUSH_TORUS, B_SIMABRUSHCHANGE, "Wrap",    xco+10,yco-25,butw,19, &brush->flag, 0, 0, 0, 0, "Enables torus wrapping");
+
+               uiBlockBeginAlign(block);
+               uiDefButBitS(block, TOG|BIT, BRUSH_AIRBRUSH, B_SIMABRUSHCHANGE, "Airbrush",     xco+10,yco-50,butw,19, &brush->flag, 0, 0, 0, 0, "Keep applying paint effect while holding mouse (spray)");
+               uiDefButF(block, NUM, B_SIMANOTHING, "Rate ", xco+10,yco-70,butw,19, &brush->rate, 0.01, 1.0, 0, 0, "Number of paints per second for Airbrush");
+               uiBlockEndAlign(block);
+
+               yco -= 25;
+
+               uiBlockBeginAlign(block);
+               uiDefButF(block, COL, B_VPCOLSLI, "",                                   0,yco,200,19, brush->rgb, 0, 0, 0, 0, "");
+               uiDefButF(block, NUMSLI, B_SIMANOTHING, "Opacity ",             0,yco-20,180,19, &brush->alpha, 0.0, 1.0, 0, 0, "The amount of pressure on the brush");
+               uiDefButBitS(block, TOG|BIT, BRUSH_ALPHA_PRESSURE, B_SIMANOTHING, "P",  180,yco-20,20,19, &brush->flag, 0, 0, 0, 0, "Enables pressure sensitivity for tablets");
+               uiDefButI(block, NUMSLI, B_SIMANOTHING, "Size ",                0,yco-40,180,19, &brush->size, 1, 200, 0, 0, "The size of the brush");
+               uiDefButBitS(block, TOG|BIT, BRUSH_SIZE_PRESSURE, B_SIMANOTHING, "P",   180,yco-40,20,19, &brush->flag, 0, 0, 0, 0, "Enables pressure sensitivity for tablets");
+               uiDefButF(block, NUMSLI, B_SIMANOTHING, "Falloff ",             0,yco-60,180,19, &brush->innerradius, 0.0, 1.0, 0, 0, "The fall off radius of the brush");
+               uiDefButBitS(block, TOG|BIT, BRUSH_RAD_PRESSURE, B_SIMANOTHING, "P",    180,yco-60,20,19, &brush->flag, 0, 0, 0, 0, "Enables pressure sensitivity for tablets");
+               uiDefButF(block, NUMSLI, B_SIMANOTHING, "Spacing ",0,yco-80,180,19, &brush->spacing, 1.0, 100.0, 0, 0, "Repeating paint on %% of brush diameter");
+               uiDefButBitS(block, TOG|BIT, BRUSH_SPACING_PRESSURE, B_SIMANOTHING, "P",        180,yco-80,20,19, &brush->flag, 0, 0, 0, 0, "Enables pressure sensitivity for tablets");
+               uiBlockEndAlign(block);
+
+               yco -= 110;
+
+               if(settings->imapaint.tool == PAINT_TOOL_CLONE) {
+                       id= (ID*)brush->clone.image;
+                       uiBlockSetCol(block, TH_BUT_SETTING2);
+                       xco= std_libbuttons(block, 0, yco, 0, NULL, B_SIMACLONEBROWSE, ID_IM, 0, id, 0, &G.sima->menunr, 0, 0, B_SIMACLONEDELETE, 0, 0);
+                       uiBlockSetCol(block, TH_AUTO);
+                       if(id) {
+                               butw= 320-(xco+5);
+                               uiDefButF(block, NUMSLI, B_SIMABRUSHCHANGE, "B ",xco+5,yco,butw,19, &brush->clone.alpha , 0.0, 1.0, 0, 0, "Opacity of clone image display");
+                       }
+               }
+               else {
+                       MTex *mtex= brush->mtex[brush->texact];
+
+                       uiBlockSetCol(block, TH_BUT_SETTING2);
+                       id= (mtex)? (ID*)mtex->tex: NULL;
+                       xco= std_libbuttons(block, 0, yco, 0, NULL, B_SIMABTEXBROWSE, ID_TE, 0, id, NULL, &(G.sima->menunr), 0, 0, B_SIMABTEXDELETE, 0, 0);
+                       /*uiDefButBitS(block, TOG|BIT, BRUSH_FIXED_TEX, B_SIMABRUSHCHANGE, "Fixed",     xco+5,yco,butw,19, &brush->flag, 0, 0, 0, 0, "Keep texture origin in fixed position");*/
+                       uiBlockSetCol(block, TH_AUTO);
+               }
+       }
 
 #if 0
-       uiDefButBitS(block, TOG|BIT, IMAGEPAINT_DRAW_TOOL_DRAWING, B_SIMABRUSHCHANGE, "TD", 890,1,50,19, &Gip.flag, 0, 0, 0, 0, "Enables tool shape while drawing");
-       uiDefButBitS(block, TOG|BIT, IMAGEPAINT_DRAW_TOOL, B_SIMABRUSHCHANGE, "TP", 940,1,50,19, &Gip.flag, 0, 0, 0, 0, "Enables tool shape while not drawing");
+               uiDefButBitS(block, TOG|BIT, IMAGEPAINT_DRAW_TOOL_DRAWING, B_SIMABRUSHCHANGE, "TD", 0,1,50,19, &settings->imapaint.flag.flag, 0, 0, 0, 0, "Enables brush shape while drawing");
+               uiDefButBitS(block, TOG|BIT, IMAGEPAINT_DRAW_TOOL, B_SIMABRUSHCHANGE, "TP", 50,1,50,19, &settings->imapaint.flag.flag, 0, 0, 0, 0, "Enables brush shape while not drawing");
 #endif
-       uiDefButBitS(block, TOG|BIT, IMAGEPAINT_TORUS, B_SIMABRUSHCHANGE, "Wrap", 890,1,50,19, &Gip.flag, 0, 0, 0, 0, "Enables torus wrapping");
 }
 
-static void image_panel_curves_reset(void *cumap_v, void *unused)
+static void image_panel_curves_reset(void *cumap_v, void *ibuf_v)
 {
        CurveMapping *cumap = cumap_v;
        int a;
@@ -992,24 +1059,28 @@ static void image_panel_curves_reset(void *cumap_v, void *unused)
        curvemapping_set_black_white(cumap, NULL, NULL);
        
        curvemapping_changed(cumap, 0);
-       curvemapping_do_image(cumap, G.sima->image);
+       curvemapping_do_ibuf(cumap, ibuf_v);
        
        allqueue(REDRAWIMAGE, 0);
 }
 
 
-static void image_panel_curves(short cntrl)    // IMAGE_HANDLER_PROPERTIES
+static void image_panel_curves(short cntrl)    // IMAGE_HANDLER_CURVES
 {
+       ImBuf *ibuf;
        uiBlock *block;
        uiBut *bt;
        
+       /* and we check for spare */
+       ibuf= imagewindow_get_ibuf(G.sima);
+       
        block= uiNewBlock(&curarea->uiblocks, "image_panel_curves", UI_EMBOSS, UI_HELV, curarea->win);
        uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
        uiSetPanelHandler(IMAGE_HANDLER_CURVES);  // for close and esc
        if(uiNewPanel(curarea, block, "Curves", "Image", 10, 450, 318, 204)==0)
                return;
        
-       if (G.sima->image && G.sima->image->ibuf) {
+       if (ibuf) {
                rctf rect;
                
                if(G.sima->cumap==NULL)
@@ -1020,7 +1091,7 @@ static void image_panel_curves(short cntrl)       // IMAGE_HANDLER_PROPERTIES
                curvemap_buttons(block, G.sima->cumap, 'c', B_SIMACURVES, B_SIMAGEDRAW, &rect);
                
                bt=uiDefBut(block, BUT, B_SIMARANGE, "Reset",   10, 160, 90, 19, NULL, 0.0f, 0.0f, 0, 0, "Reset Black/White point and curves");
-               uiButSetFunc(bt, image_panel_curves_reset, G.sima->cumap, NULL);
+               uiButSetFunc(bt, image_panel_curves_reset, G.sima->cumap, ibuf);
                
                uiBlockBeginAlign(block);
                uiDefButF(block, NUM, B_SIMARANGE, "Min R:",    10, 120, 90, 19, G.sima->cumap->black, -1000.0f, 1000.0f, 10, 2, "Black level");
@@ -1052,6 +1123,9 @@ static int image_curves_active(ScrArea *sa)
        return 0;
 }
 
+/* 0: disable preview 
+   otherwise refresh preview
+*/
 void image_preview_event(int event)
 {
        int exec= 0;
@@ -1061,24 +1135,35 @@ void image_preview_event(int event)
                G.scene->r.scemode &= ~R_COMP_CROP;
                exec= 1;
        }
-       else if(event==2 || (G.scene->r.scemode & R_COMP_CROP)==0) {
+       else {
                if(image_preview_active(curarea, NULL, NULL)) {
                        G.scene->r.scemode |= R_COMP_CROP;
                        exec= 1;
                }
+               else
+                       G.scene->r.scemode &= ~R_COMP_CROP;
        }
        
-       if(exec) {
-               ScrArea *sa;
+       if(exec && G.scene->nodetree) {
+               /* should work when no node editor in screen..., so we execute right away */
                
                ntreeCompositTagGenerators(G.scene->nodetree);
-       
-               for(sa=G.curscreen->areabase.first; sa; sa= sa->next) {
-                       if(sa->spacetype==SPACE_NODE) {
-                               addqueue(sa->win, UI_BUT_EVENT, B_NODE_TREE_EXEC);
-                               break;
-                       }
-               }
+
+               G.afbreek= 0;
+               G.scene->nodetree->timecursor= set_timecursor;
+               G.scene->nodetree->test_break= blender_test_break;
+               
+               BIF_store_spare();
+               
+               ntreeCompositExecTree(G.scene->nodetree, &G.scene->r, 1);       /* 1 is do_previews */
+               
+               G.scene->nodetree->timecursor= NULL;
+               G.scene->nodetree->test_break= NULL;
+               
+               scrarea_do_windraw(curarea);
+               waitcursor(0);
+               
+               allqueue(REDRAWNODE, 1);
        }       
 }
 
@@ -1097,11 +1182,7 @@ static void preview_cb(struct ScrArea *sa, struct uiBlock *block)
                winy*= (G.scene->r.border.ymax - G.scene->r.border.ymin);
        }
        
-       /* while dragging we don't update the rects */
-       if(block->panel->flag & PNL_SELECT)
-               return;
-       if(get_mbut() & M_MOUSE)
-               return;
+       /* while dragging we need to update the rects, otherwise it doesn't end with correct one */
 
        BLI_init_rctf(&dispf, 15.0f, (block->maxx - block->minx)-15.0f, 15.0f, (block->maxy - block->miny)-15.0f);
        ui_graphics_to_window_rct(sa->win, &dispf, disprect);
@@ -1128,20 +1209,25 @@ static void preview_cb(struct ScrArea *sa, struct uiBlock *block)
        CLAMP(disprect->ymin, 0, winy);
        CLAMP(disprect->ymax, 0, winy);
 //     printf("drawrct %d %d %d %d\n", disprect->xmin, disprect->ymin,disprect->xmax, disprect->ymax);
-       
-       image_preview_event(1);
+
 }
 
 static int is_preview_allowed(ScrArea *cur)
 {
+       SpaceImage *sima= cur->spacedata.first;
        ScrArea *sa;
 
+       /* check if another areawindow has preview set */
        for(sa=G.curscreen->areabase.first; sa; sa= sa->next) {
                if(sa!=cur && sa->spacetype==SPACE_IMAGE) {
                        if(image_preview_active(sa, NULL, NULL))
                           return 0;
                }
        }
+       /* check image type */
+       if(sima->image==NULL || sima->image->type!=IMA_TYPE_COMPOSITE)
+               return 0;
+       
        return 1;
 }
 
@@ -1153,6 +1239,7 @@ static void image_panel_preview(ScrArea *sa, short cntrl) // IMAGE_HANDLER_PREVI
        
        if(is_preview_allowed(sa)==0) {
                rem_blockhandler(sa, IMAGE_HANDLER_PREVIEW);
+               G.scene->r.scemode &= ~R_COMP_CROP;     /* quite weak */
                return;
        }
        
@@ -1182,6 +1269,9 @@ static void image_blockhandlers(ScrArea *sa)
                case IMAGE_HANDLER_PROPERTIES:
                        image_panel_properties(sima->blockhandler[a+1]);
                        break;
+               case IMAGE_HANDLER_GAME_PROPERTIES:
+                       image_panel_game_properties(sima->blockhandler[a+1]);
+                       break;
                case IMAGE_HANDLER_PAINT:
                        image_panel_paint(sima->blockhandler[a+1]);
                        break;          
@@ -1198,6 +1288,53 @@ static void image_blockhandlers(ScrArea *sa)
        uiDrawBlocksPanels(sa, 0);
 }
 
+void imagespace_composite_flipbook(ScrArea *sa)
+{
+       SpaceImage *sima= sa->spacedata.first;
+       ImBuf *ibuf;
+       int cfrao= G.scene->r.cfra;
+       int sfra, efra;
+       
+       if(sa->spacetype!=SPACE_IMAGE)
+               return;
+       if(sima->iuser.frames<2)
+               return;
+       if(G.scene->nodetree==NULL)
+               return;
+       
+       sfra= sima->iuser.sfra;
+       efra= sima->iuser.sfra + sima->iuser.frames-1;
+       G.scene->nodetree->test_break= blender_test_break;
+       
+       for(G.scene->r.cfra=sfra; G.scene->r.cfra<=efra; G.scene->r.cfra++) {
+               
+               set_timecursor(CFRA);
+               
+               BKE_image_all_free_anim_ibufs(CFRA);
+               ntreeCompositTagAnimated(G.scene->nodetree);
+               ntreeCompositExecTree(G.scene->nodetree, &G.scene->r, G.scene->r.cfra!=cfrao);  /* 1 is no previews */
+               
+               force_draw(0);
+               
+               ibuf= BKE_image_get_ibuf(sima->image, &sima->iuser);
+               /* save memory in flipbooks */
+               if(ibuf)
+                       imb_freerectfloatImBuf(ibuf);
+               
+               if(blender_test_break())
+                       break;
+       }
+       G.scene->nodetree->test_break= NULL;
+       waitcursor(0);
+       
+       play_anim(0);
+       
+       allqueue(REDRAWNODE, 1);
+       allqueue(REDRAWIMAGE, 1);
+       
+       G.scene->r.cfra= cfrao;
+}
+
 static void imagespace_grid(SpaceImage *sima)
 {
        float gridsize, gridstep= 1.0f/32.0f;
@@ -1302,7 +1439,8 @@ static void sima_draw_alpha_pixels(float x1, float y1, int rectx, int recty, uns
 {
        
        /* swap bytes, so alpha is most significant one, then just draw it as luminance int */
-       glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+       if(G.order==B_ENDIAN)
+               glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
        glaDrawPixelsSafe(x1, y1, rectx, recty, rectx, GL_LUMINANCE, GL_UNSIGNED_INT, recti);
        glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
 }
@@ -1390,8 +1528,9 @@ static void imagewindow_draw_renderinfo(ScrArea *sa)
        SpaceImage *sima= sa->spacedata.first;
        rcti rect;
        float colf[3];
+       char *str= sima->showspare?sima->info_spare:sima->info_str;
        
-       if(sima->info_str==NULL)
+       if(str==NULL)
                return;
        
        rect= sa->winrct;
@@ -1406,17 +1545,22 @@ static void imagewindow_draw_renderinfo(ScrArea *sa)
        
        BIF_ThemeColor(TH_TEXT_HI);
        glRasterPos2i(12, 5);
-       BMF_DrawString(G.fonts, sima->info_str);
+       if(sima->showspare) {
+               BMF_DrawString(G.fonts, "(Previous)");
+               glRasterPos2i(72, 5);
+       }               
+       BMF_DrawString(G.fonts, str);
 }
 
 void drawimagespace(ScrArea *sa, void *spacedata)
 {
        SpaceImage *sima= spacedata;
        ImBuf *ibuf= NULL;
+       Brush *brush;
        float col[3];
        unsigned int *rect;
        float x1, y1;
-       short sx, sy, dx, dy, show_render= 0;
+       short sx, sy, dx, dy, show_render= 0, show_viewer= 0;
        
                /* If derived data is used then make sure that object
                 * is up-to-date... might not be the case because updates
@@ -1434,24 +1578,30 @@ void drawimagespace(ScrArea *sa, void *spacedata)
        bwin_clear_viewmat(sa->win);    /* clear buttons view */
        glLoadIdentity();
        
-       if(sima->image && BLI_streq(sima->image->name, "Render Result") )
-               show_render= 1;
-       
+       if(sima->image && sima->image->source==IMA_SRC_VIEWER) {
+               show_viewer= 1;
+               if(sima->image->type==IMA_TYPE_R_RESULT)
+                       show_render= 1;
+       }
        what_image(sima);
        
        if(sima->image) {
-               if(sima->image->ibuf==NULL) {
-                       load_image(sima->image, IB_rect, G.sce, G.scene->r.cfra);
-                       scrarea_queue_headredraw(sa);   /* update header for image options */
-               }
                
-               tag_image_time(sima->image);
-               ibuf= sima->image->ibuf;
+               /* UGLY hack? until now iusers worked fine... but for flipbook viewer we need this */
+               if(sima->image->type==IMA_TYPE_COMPOSITE) {
+                       ImageUser *iuser= ntree_get_active_iuser(G.scene->nodetree);
+                       if(iuser) {
+                               BKE_image_user_calc_imanr(iuser, G.scene->r.cfra, 0);
+                               G.sima->iuser= *iuser;
+                       }
+               }
+               /* and we check for spare */
+               ibuf= imagewindow_get_ibuf(sima);
        }
        
        if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL)) {
                imagespace_grid(sima);
-               if(show_render==0)
+               if(show_viewer==0)
                        draw_tfaces();
        }
        else {
@@ -1547,29 +1697,35 @@ void drawimagespace(ScrArea *sa, void *spacedata)
                                if(sima->flag & SI_SHOW_ALPHA) {
                                        if(ibuf->rect)
                                                sima_draw_alpha_pixels(x1, y1, ibuf->x, ibuf->y, ibuf->rect);
-                                       else if(ibuf->rect_float)
+                                       else if(ibuf->rect_float && ibuf->channels==4)
                                                sima_draw_alpha_pixelsf(x1, y1, ibuf->x, ibuf->y, ibuf->rect_float);
                                }
                                else if(sima->flag & SI_SHOW_ZBUF) {
                                        if(ibuf->zbuf)
                                                sima_draw_zbuf_pixels(x1, y1, ibuf->x, ibuf->y, ibuf->zbuf);
-                                       else
+                                       else if(ibuf->zbuf_float)
                                                sima_draw_zbuffloat_pixels(x1, y1, ibuf->x, ibuf->y, ibuf->zbuf_float);
+                                       else if(ibuf->channels==1)
+                                               sima_draw_zbuffloat_pixels(x1, y1, ibuf->x, ibuf->y, ibuf->rect_float);
                                }
                                else {
                                        if(sima->flag & SI_USE_ALPHA) {
                                                sima_draw_alpha_backdrop(sima, x1, y1, (float)ibuf->x, (float)ibuf->y);
                                                glEnable(GL_BLEND);
+                                               glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                                        }
                                        
                                        /* detect if we need to redo the curve map. 
                                           ibuf->rect is zero for compositor and render results after change 
                                           convert to 32 bits always... drawing float rects isnt supported well (atis)
+                                       
+                                          NOTE: if float buffer changes, we have to manually remove the rect
                                        */
+                                       
                                        if(ibuf->rect_float) {
                                                if(ibuf->rect==NULL) {
                                                        if(image_curves_active(sa))
-                                                               curvemapping_do_image(G.sima->cumap, G.sima->image);
+                                                               curvemapping_do_ibuf(G.sima->cumap, ibuf);
                                                        else 
                                                                IMB_rect_from_float(ibuf);
                                                }
@@ -1585,7 +1741,8 @@ void drawimagespace(ScrArea *sa, void *spacedata)
                                }
                        }
                        
-                       if(Gip.current == IMAGEPAINT_CLONE) {
+                       brush= G.scene->toolsettings->imapaint.brush;
+                       if(brush && (G.scene->toolsettings->imapaint.tool == PAINT_TOOL_CLONE)) {
                                int w, h;
                                unsigned char *clonerect;
 
@@ -1595,8 +1752,8 @@ void drawimagespace(ScrArea *sa, void *spacedata)
 
                                if(clonerect) {
                                        int offx, offy;
-                                       offx = sima->zoom*ibuf->x * + Gip.clone.offset[0];
-                                       offy = sima->zoom*ibuf->y * + Gip.clone.offset[1];
+                                       offx = sima->zoom*ibuf->x * + brush->clone.offset[0];
+                                       offy = sima->zoom*ibuf->y * + brush->clone.offset[1];
 
                                        glEnable(GL_BLEND);
                                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -1609,7 +1766,7 @@ void drawimagespace(ScrArea *sa, void *spacedata)
                        
                        glPixelZoom(1.0, 1.0);
                        
-                       if(show_render==0) 
+                       if(show_viewer==0) 
                                draw_tfaces();
                }
 
@@ -1667,7 +1824,9 @@ static void image_zoom_set_factor(float zoomfac)
        width= 256;
        height= 256;
        if (sima->image) {
-               if (sima->image->ibuf) {
+               ImBuf *ibuf= imagewindow_get_ibuf(sima);
+
+               if (ibuf) {
                        float xim, yim;
                        /* I know a bit weak... but preview uses not actual image size */
                        if(image_preview_active(curarea, &xim, &yim)) {
@@ -1675,8 +1834,8 @@ static void image_zoom_set_factor(float zoomfac)
                                height= (int) yim;
                        }
                        else {
-                               width= sima->image->ibuf->x;
-                               height= sima->image->ibuf->y;
+                               width= ibuf->x;
+                               height= ibuf->y;
                        }
                }
        }
@@ -1694,10 +1853,17 @@ static void image_zoom_set_factor(float zoomfac)
 void image_viewmove(int mode)
 {
        short mval[2], mvalo[2], zoom0;
+       int oldcursor;
+       Window *win;
        
        getmouseco_sc(mvalo);
        zoom0= G.sima->zoom;
        
+       oldcursor=get_cursor();
+       win=winlay_get_active_window();
+       
+       SetBlenderCursor(BC_NSEW_SCROLLCURSOR);
+       
        while(get_mbut()&(L_MOUSE|M_MOUSE)) {
 
                getmouseco_sc(mval);
@@ -1723,6 +1889,7 @@ void image_viewmove(int mode)
                }
                else BIF_wait_for_statechange();
        }
+       window_set_cursor(win, oldcursor);
        
        if(image_preview_active(curarea, NULL, NULL)) {
                /* recalculates new preview rect */
@@ -1769,18 +1936,20 @@ void image_viewzoom(unsigned short event, int invert)
  */
 void image_home(void)
 {
+       ImBuf *ibuf;
        int width, height, imgwidth, imgheight;
        float zoomX, zoomY;
 
        if (curarea->spacetype != SPACE_IMAGE) return;
-
-       if ((G.sima->image == NULL) || (G.sima->image->ibuf == NULL)) {
+       ibuf= imagewindow_get_ibuf(G.sima);
+       
+       if (ibuf == NULL) {
                imgwidth = 256;
                imgheight = 256;
        }
        else {
-               imgwidth = G.sima->image->ibuf->x;
-               imgheight = G.sima->image->ibuf->y;
+               imgwidth = ibuf->x;
+               imgheight = ibuf->y;
        }
 
        /* Check if the image will fit in the image with zoom==1 */
@@ -1806,17 +1975,18 @@ void image_home(void)
        scrarea_queue_winredraw(curarea);
 }
 
-void image_viewcentre(void)
+void image_viewcenter(void)
 {
+       ImBuf *ibuf= BKE_image_get_ibuf(G.sima->image, &G.sima->iuser);
        float size, min[2], max[2], d[2], xim=256.0f, yim=256.0f;
 
        if( is_uv_tface_editing_allowed()==0 ) return;
 
        if (!minmax_tface_uv(min, max)) return;
 
-       if(G.sima->image && G.sima->image->ibuf) {
-               xim= G.sima->image->ibuf->x;
-               yim= G.sima->image->ibuf->y;
+       if(ibuf) {
+               xim= ibuf->x;
+               yim= ibuf->y;
        }
 
        G.sima->xof= (int) (((min[0] + max[0])*0.5f - 0.5f)*xim);
@@ -1879,7 +2049,7 @@ static void imagewindow_progress(ScrArea *sa, RenderResult *rr, volatile rcti *r
                rectf= rr->rectf;
        else {
                if(rr->rect32)
-                       rect32= rr->rect32;
+                       rect32= (unsigned int *)rr->rect32;
                else {
                        if(rr->renlay==NULL || rr->renlay->rectf==NULL) return;
                        rectf= rr->renlay->rectf;
@@ -1907,7 +2077,7 @@ static void imagewindow_progress(ScrArea *sa, RenderResult *rr, volatile rcti *r
        if(rect32)
                glaDrawPixelsSafe(x1, y1, xmax, ymax, rr->rectx, GL_RGBA, GL_UNSIGNED_BYTE, rect32);
        else
-               glaDrawPixelsSafe(x1, y1, xmax, ymax, rr->rectx, GL_RGBA, GL_FLOAT, rectf);
+               glaDrawPixelsSafe_to32(x1, y1, xmax, ymax, rr->rectx, rectf);
        
        glPixelZoom(1.0, 1.0);
        
@@ -1915,13 +2085,16 @@ static void imagewindow_progress(ScrArea *sa, RenderResult *rr, volatile rcti *r
 
 
 /* in render window; display a couple of scanlines of rendered image */
+/* NOTE: called while render, so no malloc allowed! */
 static void imagewindow_progress_display_cb(RenderResult *rr, volatile rcti *rect)
 {
        
        if (image_area) {
+               
                imagewindow_progress(image_area, rr, rect);
-               image_area->win_swap= WIN_BACK_OK;
-               screen_swapbuffers();
+
+               /* no screen_swapbuffers, prevent any other window to draw */
+               myswapbuffers();
        }
 }
 
@@ -1973,7 +2146,7 @@ static ScrArea *biggest_area(void)
       make a new temp fullscreen area with Image Window
 */
 
-static ScrArea *imagewindow_set_render_display(void)
+static ScrArea *find_area_showing_r_result(void)
 {
        ScrArea *sa;
        SpaceImage *sima;
@@ -1982,11 +2155,20 @@ static ScrArea *imagewindow_set_render_display(void)
        for(sa=G.curscreen->areabase.first; sa; sa= sa->next) {
                if(sa->spacetype==SPACE_IMAGE) {
                        sima= sa->spacedata.first;
-                       
-                       if(sima->image && BLI_streq(sima->image->name, "Render Result") )
+                       if(sima->image && sima->image->type==IMA_TYPE_R_RESULT)
                                break;
                }
        }
+       return sa;
+}
+
+static ScrArea *imagewindow_set_render_display(void)
+{
+       ScrArea *sa;
+       SpaceImage *sima;
+       
+       sa= find_area_showing_r_result();
+       
        if(sa==NULL) {
                /* find largest open non-image area */
                sa= biggest_non_image_area();
@@ -2013,20 +2195,7 @@ static ScrArea *imagewindow_set_render_display(void)
        sima= sa->spacedata.first;
        
        /* get the correct image, and scale it */
-       sima->image = (Image *)find_id("IM", "Render Result");
-       
-       if(sima->image==NULL) {
-               Image *ima= alloc_libblock(&G.main->image, ID_IM, "Render Result");
-               strcpy(ima->name, "Render Result");
-               ima->ok= 1;
-               ima->xrep= ima->yrep= 1;
-               sima->image= ima;
-       }
-       else if(sima->image->id.us==0)  /* well... happens on reload, dunno yet what todo, imagewindow cannot be user when hidden*/
-               sima->image->id.us= 1;
-       
-       IMB_freeImBuf(sima->image->ibuf);
-       sima->image->ibuf= NULL;
+       sima->image= BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
        
        if(G.displaymode==R_DISPLAYSCREEN) {
                if(sa->full==0) {
@@ -2051,6 +2220,9 @@ static void imagewindow_init_display_cb(RenderResult *rr)
                
                areawinset(image_area->win);
                
+               if(sima->info_str==NULL)
+                       sima->info_str= MEM_callocN(RW_MAXTEXT, "info str imagewin");
+               
                /* calc location using original size (tiles don't tell) */
                sima->centx= (image_area->winx - sima->zoom*(float)rr->rectx)/2.0f;
                sima->centy= (image_area->winy - sima->zoom*(float)rr->recty)/2.0f;
@@ -2076,7 +2248,7 @@ void imagewindow_toggle_render(void)
                if(sa->spacetype==SPACE_IMAGE) {
                        SpaceImage *sima= sa->spacedata.first;
                        
-                       if(sima->image && BLI_streq(sima->image->name, "Render Result") )
+                       if(sima->image && sima->image->type==IMA_TYPE_R_RESULT)
                                if(sima->flag & (SI_PREVSPACE|SI_FULLWINDOW))
                                        break;
                }
@@ -2091,26 +2263,23 @@ void imagewindow_toggle_render(void)
        }
 }
 
+/* NOTE: called while render, so no malloc allowed! */
 static void imagewindow_renderinfo_cb(RenderStats *rs)
 {
        
        if(image_area) {
                SpaceImage *sima= image_area->spacedata.first;
                
-               if(sima->info_str==NULL)
-                       sima->info_str= MEM_callocN(RW_MAXTEXT, "info str imagewin");
-               
                if(rs)
                        make_renderinfo_string(rs, sima->info_str);
 
                imagewindow_draw_renderinfo(image_area);
                
-               image_area->win_swap= WIN_BACK_OK;
-               screen_swapbuffers();
+               /* no screen_swapbuffers, prevent any other window to draw */
+               myswapbuffers();
        }
 }
 
-
 void imagewindow_render_callbacks(Render *re)
 {
        RE_display_init_cb(re, imagewindow_init_display_cb);
@@ -2119,3 +2288,54 @@ void imagewindow_render_callbacks(Render *re)
        RE_stats_draw_cb(re, imagewindow_renderinfo_cb);        
 }
 
+void imagewin_store_spare(void)
+{
+       ScrArea *sa= find_area_showing_r_result();
+
+       if(sa) {
+               ImBuf *ibuf;
+               SpaceImage *sima= sa->spacedata.first;
+               
+               if(sima->spare==NULL)
+                       return;
+               
+               /* only store when it does not show spare */
+               if(sima->showspare==0)
+                       return;
+               sima->showspare= 0;
+               
+               /* free spare */
+               IMB_freeImBuf(sima->spare);
+               
+               /* make a copy of render result */
+               ibuf= BKE_image_get_ibuf(sima->image, &sima->iuser);
+               sima->spare= IMB_dupImBuf(ibuf);
+               
+               if(sima->info_str)
+                       BLI_strncpy(sima->info_spare, sima->info_str, RW_MAXTEXT);
+
+       }
+}
+
+/* context: in current image window? */
+void imagewindow_swap_render_rects(void)
+{
+       ScrArea *sa= find_area_showing_r_result();
+                                       
+       if(sa) {
+               SpaceImage *sima= sa->spacedata.first;
+               ImBuf *ibuf= BKE_image_get_ibuf(sima->image, &sima->iuser);
+               if(ibuf) {
+                       
+                       sima->showspare ^= 1;
+                       
+                       if(sima->spare==NULL)
+                               sima->spare= IMB_allocImBuf(ibuf->x, ibuf->y, 32, 0, 0);
+                       if(sima->info_spare==NULL)
+                               sima->info_spare= MEM_callocN(RW_MAXTEXT, "info str imagewin");
+                       
+                       allqueue(REDRAWIMAGE, 0);
+               }
+       }
+}
+