WINDOWS.C

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */


/* file WINDOWS.C */

// The code to construct the off screen windows and to draw the
// the windows.

#define MODULE_WINDOWS 1

#include "design.h"

static HBITMAP hbmold[3]={NULL,NULL,NULL},hbmoldv=NULL;

BOOL CreateMemoryWindows(void){
 int i;
 RECT rc;
 HDC hdc;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   hdc=GetDC(ghwnd_triview[i]);
   GetClientRect(ghwnd_triview[i],&rc);
   if(rc.bottom == 0 || rc.right == 0){
     ReleaseDC(ghwnd_triview[i],hdc);
     return FALSE;
   }
   ghdc_triview_Bitmap[i]=CreateCompatibleDC(hdc);
   if(ghdc_triview_Bitmap[i] == NULL)return FALSE;
   SelectPalette(ghdc_triview_Bitmap[i],ghpaletteScreen,FALSE);
   RealizePalette(ghdc_triview_Bitmap[i]);
   SelectObject(ghdc_triview_Bitmap[i],ghbrushWindow);
   ghbm_triview[i]=CreateCompatibleBitmap(hdc,rc.right,rc.bottom);
   if(ghbm_triview[i] == NULL)return FALSE;
   ReleaseDC(ghwnd_triview[i],hdc);
   hbmold[i]=SelectObject(ghdc_triview_Bitmap[i],ghbm_triview[i]);
   PatBlt(ghdc_triview_Bitmap[i],0,0,rc.right,rc.bottom,PATCOPY);
 }
 hdc=GetDC(ghwnd_view);
 GetClientRect(ghwnd_view,&rc);
 if(rc.bottom == 0 || rc.right == 0){
   ReleaseDC(ghwnd_view,hdc);
   return FALSE;
 }
 ghdc_view_Bitmap=CreateCompatibleDC(hdc);
 if(ghdc_view_Bitmap == NULL)return FALSE;
 SelectPalette(ghdc_view_Bitmap,ghpaletteScreen,FALSE);
 RealizePalette(ghdc_view_Bitmap);
 SelectObject(ghdc_view_Bitmap,ghbrushWindow);
 ghbm_view=CreateCompatibleBitmap(hdc,rc.right,rc.bottom);
 if(ghbm_view == NULL)return FALSE;
 ReleaseDC(ghwnd_view,hdc);
 hbmoldv=SelectObject(ghdc_view_Bitmap,ghbm_view);
 PatBlt(ghdc_view_Bitmap,0,0,rc.right,rc.bottom,PATCOPY);
 return TRUE;
}

void DeleteMemoryWindows(void){
 int i;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   if(ghdc_triview_Bitmap[i] != NULL){
     if(hbmold[i] != NULL)SelectObject(ghdc_triview_Bitmap[i],hbmold[i]);
     DeleteDC(ghdc_triview_Bitmap[i]);
   }
   hbmold[i]=NULL;
   ghdc_triview_Bitmap[i]=NULL;
   if(ghbm_triview[i] != NULL)DeleteObject(ghbm_triview[i]);
   ghbm_triview[i]=NULL;
 }
 if(ghdc_view_Bitmap != NULL){
   if(hbmoldv != NULL)SelectObject(ghdc_view_Bitmap,hbmoldv);
   DeleteDC(ghdc_view_Bitmap);
 }
 hbmoldv=NULL;
 ghdc_view_Bitmap=NULL;
 if(ghbm_view != NULL)DeleteObject(ghbm_view);
 ghbm_view=NULL;
}

void SetWindowSize(int x, int y, int view, BOOL reset){
 static int last_screenXsize,last_screenYsize;
 int i,Wsx,Wsy;
 x=max(x,20);
 y=max(y,20);
 if(reset){
   last_screenXsize=x;
   last_screenYsize=y;
   ToolbuttonSize=32;
   if(bToolpannelSmall)ToolpannelSpace=32;
   else                ToolpannelSpace=50;
   ToolpannelSpace += 4;
   WindowGap=2;
   WindowTopOrigin=1;
 }
 WindowLeftOrigin=WindowGap;
 Wsy=y-InfoWindowSize-WindowTopOrigin-WindowGap;
 Wsx=x-ToolpannelSpace-WindowLeftOrigin-WindowGap;
 TriviewSpaceX=Wsx;
 TriviewSpaceY=Wsy;
 if(bToolpannelLeft)WindowLeftOrigin += ToolpannelSpace;
 if(View == TRIVIEW){
   TriviewSpaceX -= 2; /* borders */
   TriviewSpaceY -= 2;
   if(reset){
     Window0sizeX=TriviewSpaceX/2;
     Window0sizeY=TriviewSpaceY/2;
   }
   Window0sizeX = (long)((double)(Window0sizeX*x)/(double)last_screenXsize);
   Window0sizeY = (long)((double)(Window0sizeY*y)/(double)last_screenYsize);
   WindowSizeX[0] = Window0sizeX;
   WindowSizeY[0] = Window0sizeY;
   WindowSizeX[1] = Window0sizeX;
   WindowSizeY[1] = TriviewSpaceY-Window0sizeY;
   WindowSizeX[2] = TriviewSpaceX-Window0sizeX;
   WindowSizeY[2] = TriviewSpaceY-Window0sizeY;
   WindowsXmin[0] = WindowLeftOrigin;
   WindowsYmin[0] = WindowTopOrigin;
   WindowsXmin[1] = WindowsXmin[0];
   WindowsYmin[1] = WindowsYmin[0]+WindowSizeY[0]+WindowGap;
   WindowsXmin[2] = WindowsXmin[1]+WindowSizeX[1]+WindowGap;
   WindowsYmin[2] = WindowsYmin[1];
   WindowViewXmin=WindowsXmin[2];
   WindowViewYmin=WindowsYmin[0];
   WindowViewXsize=WindowSizeX[2];
   WindowViewYsize=WindowSizeY[0];
 }
 else{
   for(i=0;i<3;i++){
     WindowsXmin[i] = WindowLeftOrigin;
     WindowsYmin[i] = WindowTopOrigin;
     WindowSizeX[i] = Wsy;
     WindowSizeY[i] = Wsy;
   }
   WindowViewXmin=WindowLeftOrigin+WindowSizeX[0];
   WindowViewYmin=WindowsYmin[0];
   WindowViewXsize=max(20,x-ToolpannelSpace-2-WindowSizeX[0]);
   WindowViewYsize=WindowViewXsize;
 }
 for(i=0;i<3;i++){
   WindowCentreX[i]=WindowSizeX[i]/2;
   WindowCentreY[i]=WindowSizeY[i]/2;
 }
 last_screenXsize=x;
 last_screenYsize=y;
}

void SwitchWindow(int button){
 char tt[128];
 int  buttontable[3][2]={{1,2},{0,2},{0,1}};
 int i,im;
 HDC hdc;
 RECT rc;
 if(button < 0){ /* switch between 3 / 1 view */
   GetClientRect(ghwnd_main,&rc);
   if(View == TRIVIEW){ /* switching to single view */
     LoadString(ghinst_main,IDX_MISC_QUADVIEW,tt,128);
     ModifyMenu(GetMenu(ghwnd_main),IDM_WINDOW_SWITCHWINDOWS,
           MF_BYCOMMAND|MF_STRING,IDM_WINDOW_SWITCHWINDOWS,tt);
     hdc=GetDC(ghwnd_main);
     FocusActiveWindow(hdc,FALSE);
     ReleaseDC(ghwnd_main,hdc);
     for(i=0;i<3;i++){
       if(i != ActiveView)EnableWindow(ghwnd_triview[i],FALSE);
       ShowWindow(ghwnd_triview[i],SW_HIDE);
     }
     if(ghwndOpenGLview == NULL)ShowWindow(ghwnd_view,SW_HIDE);
     else                       ShowWindow(ghwndOpenGLview,SW_HIDE);
     DeleteMemoryWindows();
     View=ONEVIEW;
     SetWindowSize(rc.right,rc.bottom,View,FALSE);
     GetTriview(FALSE);
     MoveWindow(ghwnd_current,
                WindowLeftOrigin,WindowTopOrigin,
                WindowSizeX[ActiveView],WindowSizeY[ActiveView],TRUE);
     MoveWindow(ghwnd_view,
                WindowViewXmin,WindowViewYmin,
                WindowViewXsize,WindowViewYsize,TRUE);
     if(ghwndOpenGLview != NULL)MoveWindow(ghwndOpenGLview,
                WindowViewXmin,WindowViewYmin,
                WindowViewXsize,WindowViewYsize,TRUE);
     CreateMemoryWindows();
     ToolboxSetPosition(1);
     ShowWindow(ghwnd_current,SW_SHOWNA);
     if(ghwndOpenGLview == NULL)ShowWindow(ghwnd_view,SW_SHOWNA);
     else                       ShowWindow(ghwndOpenGLview,SW_SHOWNA);
     DrawModel();
     if(ghwndOpenGLview == NULL)Draw3dView(0,0);
     else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
   }
   else{
     LoadString(ghinst_main,IDX_MISC_SINGLEVIEW,tt,128);
     ModifyMenu(GetMenu(ghwnd_main),IDM_WINDOW_SWITCHWINDOWS,
           MF_BYCOMMAND|MF_STRING,IDM_WINDOW_SWITCHWINDOWS,tt);
     if(ghwndOpenGLview == NULL)ShowWindow(ghwnd_view,SW_HIDE);
     else                       ShowWindow(ghwndOpenGLview,SW_HIDE);
     ShowWindow(ghwnd_current,SW_HIDE);
     DeleteMemoryWindows();
     View=TRIVIEW;
     SetWindowSize(rc.right,rc.bottom,View,FALSE);
     GetTriview(FALSE);
     for(i=0;i<3;i++)
       MoveWindow(ghwnd_triview[i],
                  WindowsXmin[i],WindowsYmin[i],
                  WindowSizeX[i],WindowSizeY[i],TRUE);
     MoveWindow(ghwnd_view,WindowViewXmin,WindowViewYmin,
                WindowViewXsize,WindowViewYsize,TRUE);
     if(ghwndOpenGLview != NULL)MoveWindow(ghwndOpenGLview,
                WindowViewXmin,WindowViewYmin,
                WindowViewXsize,WindowViewYsize,TRUE);
     CreateMemoryWindows();
     for(i=0;i<3;i++){
       if(i != ActiveView)EnableWindow(ghwnd_triview[i],TRUE);
       ShowWindow(ghwnd_triview[i],SW_SHOWNA);
     }
     ToolboxSetPosition(0);
     if(ghwndOpenGLview == NULL)ShowWindow(ghwnd_view,SW_SHOWNA);
     else                       ShowWindow(ghwndOpenGLview,SW_SHOWNA);
     DrawModel();
     if(ghwndOpenGLview == NULL)Draw3dView(0,0);
     else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
     hdc=GetDC(ghwnd_main);
     FocusActiveWindow(hdc,TRUE);
     ReleaseDC(ghwnd_main,hdc);
   }
 }
 else {
  int activetable[3][2]={
    {TRIFRONT,TRIRIGHT},
    {TRITOP,  TRIRIGHT},
    {TRITOP,  TRIFRONT}
   };
   ShowWindow(ghwnd_current,SW_HIDE);
   EnableWindow(ghwnd_triview[ActiveView],FALSE);
   DeleteMemoryWindows();
   ActiveView=activetable[ActiveView][button];
   ghwnd_current=ghwnd_triview[ActiveView];
   GetTriview(FALSE);
   MoveWindow(ghwnd_current,
              WindowLeftOrigin,WindowTopOrigin,
              WindowSizeX[ActiveView],WindowSizeY[ActiveView],TRUE);
   CreateMemoryWindows();
   ToolboxSetPosition(1);
   EnableWindow(ghwnd_triview[ActiveView],TRUE);
   ShowWindow(ghwnd_triview[ActiveView],SW_SHOWNA);
   DrawModel();
 }
}

void FormatScreen(void){
 HDC hdc;
 RECT rc;
 int i;
 if(View == TRIVIEW){
   hdc=GetDC(ghwnd_main);
   FocusActiveWindow(hdc,FALSE);
 }
 DeleteMemoryWindows();
 GetClientRect(ghwnd_main,&rc);
 SetWindowSize(rc.right,rc.bottom,View,FALSE);
 GetTriview(FALSE);
 for(i=0;i<3;i++)
    MoveWindow(ghwnd_triview[i],
               WindowsXmin[i],WindowsYmin[i],
               WindowSizeX[i],WindowSizeY[i],TRUE);
 MoveWindow(ghwnd_view,WindowViewXmin,WindowViewYmin,
               WindowViewXsize,WindowViewYsize,TRUE);
 if(ghwndOpenGLview != NULL)MoveWindow(ghwndOpenGLview,
               WindowViewXmin,WindowViewYmin,
               WindowViewXsize,WindowViewYsize,TRUE);
 if(View == TRIVIEW){
   FocusActiveWindow(hdc,TRUE);
   ReleaseDC(ghwnd_main,hdc);
 }
 CreateMemoryWindows();
 DrawModel();
 if(ghwndOpenGLview == NULL)Draw3dView(0,0);
 else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
}

void UpdateIconPositions(void){
 HDC hdc;
 RECT rc;
 int i;
 if(View == TRIVIEW){
   hdc=GetDC(ghwnd_main);
   FocusActiveWindow(hdc,FALSE);
   ReleaseDC(ghwnd_main,hdc);
 }
 DeleteMemoryWindows();
 GetClientRect(ghwnd_main,&rc);
 SetWindowSize(rc.right,rc.bottom,View,TRUE);
 GetTriview(FALSE);
 for(i=0;i<3;i++)
   MoveWindow(ghwnd_triview[i],
              WindowsXmin[i],WindowsYmin[i],
              WindowSizeX[i],WindowSizeY[i],TRUE);
 MoveWindow(ghwnd_view,WindowViewXmin,WindowViewYmin,
              WindowViewXsize,WindowViewYsize,TRUE);
 if(ghwndOpenGLview != NULL)MoveWindow(ghwndOpenGLview,
              WindowViewXmin,WindowViewYmin,
              WindowViewXsize,WindowViewYsize,TRUE);
 MoveToolsWindow();
 InvalidateRect(ghwndTools,NULL,FALSE);
 UpdateWindow(ghwndTools);
 if(View == TRIVIEW){
   hdc=GetDC(ghwnd_main);
   FocusActiveWindow(hdc,TRUE);
   ReleaseDC(ghwnd_main,hdc);
 }
 CreateMemoryWindows();
 DrawModel();
 if(ghwndOpenGLview == NULL)Draw3dView(0,0);
 else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
}

void FocusActiveWindow(HDC hdc, BOOL place){
 RECT rc;
 POINT pc;
 HPEN hOldPen;
 if(View == ONEVIEW)return;
 GetWindowRect(ghwnd_current,&rc);
 pc.x=rc.left; pc.y=rc.top;
 ScreenToClient(ghwnd_main,&pc);
 rc.left=pc.x-1; rc.top=pc.y-1;
 pc.x=rc.right; pc.y=rc.bottom;
 ScreenToClient(ghwnd_main,&pc);
 rc.right=pc.x+1; rc.bottom=pc.y+1;
 if(!place){
   RECT rc1;
   rc.left  -= 1;
   rc.right += 1;
   CopyRect(&rc1,&rc);
   rc1.bottom = rc1.top+1;
   InvalidateRect(ghwnd_main,&rc1,TRUE);
   CopyRect(&rc1,&rc);
   rc1.top = rc1.bottom-1;
   InvalidateRect(ghwnd_main,&rc1,TRUE);
   CopyRect(&rc1,&rc);
   rc1.right = rc1.left+2;
   InvalidateRect(ghwnd_main,&rc1,TRUE);
   CopyRect(&rc1,&rc);
   rc1.left = rc1.right-2;
   InvalidateRect(ghwnd_main,&rc1,TRUE);
 }
 else
 { DWORD oldROP;
   HPALETTE hpalT;
   hpalT = SelectPalette(hdc,ghpaletteScreen,FALSE);
   RealizePalette (hdc);
//   oldROP=SetROP2(hdc,R2_NOT);
   hOldPen=SelectObject(hdc,ghSelectedPen);
//   hOldPen=SelectObject(hdc,GetStockObject(WHITE_PEN));
   MoveToEx(hdc,rc.left,rc.top,NULL);
   LineTo(hdc,rc.right,rc.top);
   LineTo(hdc,rc.right,rc.bottom-1);
   LineTo(hdc,rc.left,rc.bottom-1);
   LineTo(hdc,rc.left,rc.top);
   MoveToEx(hdc,rc.left-1,rc.top,NULL);
   LineTo(hdc,rc.left-1,rc.bottom-1);
   MoveToEx(hdc,rc.right-1,rc.top,NULL);
   LineTo(hdc,rc.right-1,rc.bottom-1);
//   SetROP2(hdc,oldROP);
   SelectObject(hdc,hOldPen);
   SelectPalette(hdc,hpalT,FALSE);
 }
}

BOOL CursorInTriview(void){
 POINT p;
 RECT  r;
 int   i;
 GetCursorPos(&p);
 if(View == TRIVIEW){
   for(i=0;i<3;i++){
     GetWindowRect(ghwnd_triview[i],&r);
     if(PtInRect(&r,p))return TRUE;
   }
 }
 else{
   GetWindowRect(ghwnd_current,&r);
   if(PtInRect(&r,p))return TRUE;
 }
 return FALSE;
}