nevrax.org : docs

00001 // View.cpp : implementation file
+00002 //
+00003 
+00004 #include "stdafx.h"
+00005 #include "resource.h"
+00006 #include "View.h"
+00007 #include "SelectionTerritoire.h"
+00008 #include "select_rotation.h"
+00009 #include "Browse.h"
+00010 #include "popup.h"
+00011 #include <direct.h>
+00012 //#include "ListGroup.h"
+00013 #include <nel/3d/tile_bank.h>
+00014 //#include "ViewPopup.h"
+00015 #include "pic\readpic.h"
+00016 
+00017 /*#ifdef _DEBUG
+00018 #define new DEBUG_NEW
+00019 #undef THIS_FILE
+00020 static char THIS_FILE[] = __FILE__;
+00021 #endif*/
+00022 
+00023 using namespace NL3D;
+00024 
+00025 extern CTileBank tileBank2;
+00026 
+00027 BEGIN_MESSAGE_MAP(CTView, CStatic)
+00028         //{{AFX_MSG_MAP(CTView)
+00029         ON_WM_DROPFILES()
+00030         ON_WM_PAINT()
+00031         ON_WM_LBUTTONDBLCLK()
+00032         ON_WM_LBUTTONDOWN()
+00033         ON_WM_RBUTTONDOWN()
+00034         //}}AFX_MSG_MAP
+00035 END_MESSAGE_MAP()
+00036 
+00037 CFont *normal_font = NULL;
+00038 //int SortTile = 0; int sortMode = 1; //or, and
+00039 __int64 flagGroupSort = 0; int showNULL = 0;
+00040 //ViewPopup *theViewPopup = 0;
+00041 
+00042 bool zouille ()
+00043 {
+00044         return (GetAsyncKeyState(VK_F2)&(1<<15)) != 0;
+00045 };
+00046 
+00047 // Rotate a buffer
+00048 void rotateBuffer (uint &Width, uint &Height, std::vector<NLMISC::CBGRA>& Tampon)
+00049 {
+00050         // Make a copy
+00051         std::vector<NLMISC::CBGRA> copy=Tampon;
+00052 
+00053         // Rotate
+00054         for (uint y=0; y<Width; y++)
+00055         {
+00056                 // Line offset
+00057                 uint tmp=y*Width;
+00058                 for (uint x=0; x<Width; x++)
+00059                 {
+00060                         Tampon[y+(Width-x-1)*Height]=copy[x+tmp];
+00061                 }
+00062         }
+00063 
+00064         // New size
+00065         uint tmp=Width;
+00066         Width=Height;
+00067         Height=tmp;
+00068 }
+00069 
+00071 // CTView
+00072 //Attention : windows veut que le buffer image commence du bas vers le haut
+00073 int _LoadBitmap(const std::string& path,LPBITMAPINFO BitmapInfo, std::vector<NLMISC::CBGRA>&Tampon, std::vector<NLMISC::CBGRA>* Alpha, int rot)
+00074 {
+00075         //vector<NLMISC::CBGRA> Tampon;
+00076         uint Width;
+00077         uint Height;
+00078         if (PIC_LoadPic(path, Tampon, Width, Height))
+00079         {
+00080                 BitmapInfo->bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
+00081                 BitmapInfo->bmiHeader.biWidth=Width;
+00082                 BitmapInfo->bmiHeader.biHeight=-(int)Height;
+00083                 BitmapInfo->bmiHeader.biPlanes=1;
+00084                 BitmapInfo->bmiHeader.biBitCount=32;
+00085                 BitmapInfo->bmiHeader.biCompression=BI_RGB;
+00086                 BitmapInfo->bmiHeader.biSizeImage=0;
+00087                 BitmapInfo->bmiHeader.biXPelsPerMeter=1;
+00088                 BitmapInfo->bmiHeader.biYPelsPerMeter=1;
+00089                 BitmapInfo->bmiHeader.biClrUsed=0;
+00090                 BitmapInfo->bmiHeader.biClrImportant=0;
+00091                 BitmapInfo->bmiColors->rgbBlue=0;
+00092                 BitmapInfo->bmiColors->rgbRed=0;
+00093                 BitmapInfo->bmiColors->rgbGreen=0;
+00094 
+00095                 while (rot)
+00096                 {
+00097                         // Rotate the buffer
+00098                         rotateBuffer (Width, Height, Tampon);
+00099                         rot--;
+00100                 }
+00101 
+00102                 if ((Alpha)&&(Alpha->size()==Tampon.size()))
+00103                 {
+00104                         // Pre mul RGB componates by Alpha one
+00105                         int nPixelCount=(int)(Width*Height);
+00106                         for (int p=0; p<nPixelCount; p++)
+00107                         {
+00108                                 // Invert alpha ?
+00109                                 int alpha=(*Alpha)[p].A;
+00110                                 Tampon[p].R=(uint8)(((int)Tampon[p].R*alpha)>>8);
+00111                                 Tampon[p].G=(uint8)(((int)Tampon[p].G*alpha)>>8);
+00112                                 Tampon[p].B=(uint8)(((int)Tampon[p].B*alpha)>>8);
+00113                         }
+00114                 }
+00115 
+00116                 return 1;
+00117         }
+00118         else
+00119                 return 0;
+00120 }
+00121 
+00122 
+00123 
+00124 
+00125 
+00126 
+00127 //TileInfo
+00128 TileInfo::TileInfo()
+00129 {
+00130         nightLoaded = 0;
+00131         alphaLoaded = 0;
+00132         loaded = 0;
+00133         Selected = 0; 
+00134 }
+00135 
+00136 
+00137 
+00138 //TileList
+00139 TileList::TileList()
+00140 {
+00141         last_id = 0; 
+00142         _tileSet = -1;
+00143 
+00144         // Add 48 transitions
+00145         int i;
+00146         for (i=0; i<CTileSet::count; i++)
+00147         {
+00148                 TileInfo info;
+00149                 info.id = i;
+00150         
+00151                 theListTransition.push_back (info);
+00152         }
+00153 
+00154         // Add 16 displacements
+00155         for (i=0; i<CTileSet::CountDisplace; i++)
+00156         {
+00157                 TileInfo info;
+00158                 info.id = i;
+00159         
+00160                 theListDisplacement.push_back (info);
+00161         }
+00162 }
+00163 
+00164 
+00165 int TileList::addTile128 ()
+00166 {
+00167 
+00168         int index;
+00169         tileBank2.getTileSet (_tileSet)->addTile128 (index, tileBank2);
+00170         nlassert (index==(sint)theList128.size());
+00171 
+00172         TileInfo info;
+00173         info.id = index;
+00174         theList128.push_back (info);
+00175 
+00176         return index;
+00177 }
+00178 
+00179 int TileList::addTile256 ()
+00180 {
+00181         int index;
+00182         tileBank2.getTileSet (_tileSet)->addTile256 (index, tileBank2);
+00183         nlassert (index==(sint)theList256.size());
+00184 
+00185         TileInfo info;
+00186         info.id = index;
+00187         theList256.push_back (info);
+00188 
+00189         return index;
+00190 }
+00191 
+00192 bool RemovePath (std::string& path, const char* absolutePathToRemplace);
+00193 
+00194 int TileList::setTile128 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
+00195 {
+00196         // Remove the absolute path from the path name
+00197         std::string troncated=name;
+00198         if (RemovePath (troncated, tileBank2.getAbsPath ().c_str()))
+00199         {
+00200                 vector<NLMISC::CBGRA> tampon;
+00201                 uint Width;
+00202                 uint Height;
+00203                 if (!PIC_LoadPic(tileBank2.getAbsPath ()+troncated, tampon, Width, Height))
+00204                 {
+00205                         MessageBox (NULL, (tileBank2.getAbsPath ()+troncated).c_str(), "Can't load bitmap.", MB_OK|MB_ICONEXCLAMATION);
+00206                         return 0;
+00207                 }
+00208                 else
+00209                 {
+00210                         CTileBorder border;
+00211                         border.set (Width, Height, tampon);
+00212 
+00213                         CTileSet::TError error;
+00214                         int pixel=-1;
+00215                         int composante=4;
+00216                         error=tileBank2.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
+00217                         if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128)&&!zouille ())
+00218                         {
+00219                                 char sTmp[512];
+00220                                 static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
+00221                                 sprintf (sTmp, "%s\nPixel: %d (%s)", CTileSet::getErrorMessage (error), pixel, comp[composante]);
+00222                                 MessageBox (NULL, sTmp, "Can't add tile", MB_OK|MB_ICONEXCLAMATION);
+00223                                 return 0;
+00224                         }
+00225                         else
+00226                         {
+00227                                 if (error==CTileSet::addFirstA128128)
+00228                                         tileBank2.getTileSet(_tileSet)->setBorder (type, border);
+00229 
+00230                                 tileBank2.getTileSet(_tileSet)->setTile128 (tile, troncated, type, tileBank2);
+00231                                 switch (type)
+00232                                 {
+00233                                 case CTile::diffuse:
+00234                                         theList128[tile].loaded=0;
+00235                                         break;
+00236                                 case CTile::additive:
+00237                                         theList128[tile].nightLoaded=0;
+00238                                         break;
+00239                                 case CTile::alpha:
+00240                                         theList128[tile].alphaLoaded=0;
+00241                                         break;
+00242                                 }
+00243                                 theList128[tile].Load (tileBank2.getTileSet(_tileSet)->getTile128(tile), NULL);
+00244                         }
+00245                 }
+00246         }
+00247         else
+00248         {
+00249                 // Error: bitmap not in the absolute path..
+00250                 char msg[512];
+00251                 sprintf (msg, "The bitmap %s is not in the absolute path %s.", name.c_str(), tileBank2.getAbsPath ().c_str());
+00252                 MessageBox (NULL, msg, "Load error", MB_OK|MB_ICONEXCLAMATION);
+00253         }
+00254 
+00255         return 1;
+00256 }
+00257 
+00258 int TileList::setTile256 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
+00259 {
+00260         // Remove the absolute path from the path name
+00261         std::string troncated=name;
+00262         if (RemovePath (troncated, tileBank2.getAbsPath ().c_str()))
+00263         {
+00264                 vector<NLMISC::CBGRA> tampon;
+00265                 uint Width;
+00266                 uint Height;
+00267                 if (!PIC_LoadPic(tileBank2.getAbsPath ()+troncated, tampon, Width, Height))
+00268                 {
+00269                         MessageBox (NULL, (tileBank2.getAbsPath ()+troncated).c_str(), "Can't load bitmap.", MB_OK|MB_ICONEXCLAMATION);
+00270                         return 0;
+00271                 }
+00272                 else
+00273                 {
+00274                         CTileBorder border;
+00275                         border.set (Width, Height, tampon);
+00276                         
+00277                         CTileSet::TError error;
+00278                         int pixel=-1;
+00279                         int composante=4;
+00280 
+00281                         if (((error=tileBank2.getTileSet(_tileSet)->checkTile256 (type, border, pixel, composante))!=CTileSet::ok)&&!zouille())
+00282                         {
+00283                                 char sTmp[512];
+00284                                 static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
+00285                                 sprintf (sTmp, "%s\nPixel: %d (%s)", CTileSet::getErrorMessage (error), pixel, comp[composante]);
+00286                                 MessageBox (NULL, sTmp, "Can't add tile", MB_OK|MB_ICONEXCLAMATION);
+00287                                 return 0;
+00288                         }
+00289                         else
+00290                         {
+00291                                 tileBank2.getTileSet(_tileSet)->setTile256 (tile, troncated, type, tileBank2);
+00292                                                 switch (type)
+00293                                 {
+00294                                 case CTile::diffuse:
+00295                                         theList256[tile].loaded=0;
+00296                                         break;
+00297                                 case CTile::additive:
+00298                                         theList256[tile].nightLoaded=0;
+00299                                         break;
+00300                                 case CTile::alpha:
+00301                                         theList256[tile].alphaLoaded=0;
+00302                                         break;
+00303                                 }
+00304                                 theList256[tile].Load (tileBank2.getTileSet(_tileSet)->getTile256(tile), NULL);
+00305                         }
+00306                 }
+00307         }
+00308         else
+00309         {
+00310                 // Error: bitmap not in the absolute path..
+00311                 char msg[512];
+00312                 sprintf (msg, "The bitmap %s is not in the absolute path %s.", name.c_str(), tileBank2.getAbsPath ().c_str());
+00313                 MessageBox (NULL, msg, "Load error", MB_OK|MB_ICONEXCLAMATION);
+00314         }
+00315 
+00316         return 1;
+00317 }
+00318 
+00319 int TileList::setTileTransition (int tile, const std::string& name, NL3D::CTile::TBitmap type)
+00320 {
+00321         // Remove the absolute path from the path name
+00322         std::string troncated=name;
+00323         if (RemovePath (troncated, tileBank2.getAbsPath ().c_str()))
+00324         {
+00325                 // No alpha, use setTileTransitionAlpha
+00326                 nlassert (CTile::alpha!=type);
+00327 
+00328                 vector<NLMISC::CBGRA> tampon;
+00329                 uint Width;
+00330                 uint Height;
+00331                 if (!PIC_LoadPic(tileBank2.getAbsPath ()+troncated, tampon, Width, Height))
+00332                 {
+00333                         MessageBox (NULL, (tileBank2.getAbsPath ()+troncated).c_str(), "Can't load bitmap.", MB_OK|MB_ICONEXCLAMATION);
+00334                         return 0;
+00335                 }
+00336                 else
+00337                 {
+00338                         CTileBorder border;
+00339                         border.set (Width, Height, tampon);
+00340                         
+00341                         CTileSet::TError error;
+00342                         int pixel=-1;
+00343                         int composante=4;
+00344                         error=tileBank2.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
+00345                         if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128)&&!zouille ())
+00346                         {
+00347                                 char sTmp[512];
+00348                                 static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
+00349                                 sprintf (sTmp, "%s\nPixel: %d (%s)", CTileSet::getErrorMessage (error), pixel, comp[composante]);
+00350                                 MessageBox (NULL, sTmp, "Can't add tile", MB_OK|MB_ICONEXCLAMATION);
+00351                                 return 0;
+00352                         }
+00353                         else
+00354                         {
+00355                                 if (error==CTileSet::addFirstA128128)
+00356                                         tileBank2.getTileSet(_tileSet)->setBorder (type, border);
+00357                                 tileBank2.getTileSet(_tileSet)->setTileTransition ((CTileSet::TTransition)tile, troncated, type, tileBank2, border);
+00358                                 switch (type)
+00359                                 {
+00360                                 case CTile::diffuse:
+00361                                         theListTransition[tile].loaded=0;
+00362                                         break;
+00363                                 case CTile::additive:
+00364                                         theListTransition[tile].nightLoaded=0;
+00365                                         break;
+00366                                 case CTile::alpha:
+00367                                         theListTransition[tile].alphaLoaded=0;
+00368                                         break;
+00369                                 }
+00370                                 theListTransition[tile].Load (tileBank2.getTileSet(_tileSet)->getTransition(tile)->getTile(), 
+00371                                         &theListTransition[tile].alphaBits);
+00372                         }
+00373                 }
+00374         }
+00375         else
+00376         {
+00377                 // Error: bitmap not in the absolute path..
+00378                 char msg[512];
+00379                 sprintf (msg, "The bitmap %s is not in the absolute path %s.", name.c_str(), tileBank2.getAbsPath ().c_str());
+00380                 MessageBox (NULL, msg, "Load error", MB_OK|MB_ICONEXCLAMATION);
+00381         }
+00382 
+00383         return 1;
+00384 }
+00385 
+00386 int TileList::setDisplacement (int tile, const std::string& name)
+00387 {
+00388         // Remove the absolute path from the path name
+00389         std::string troncated=name;
+00390         if (RemovePath (troncated, tileBank2.getAbsPath ().c_str()))
+00391         {
+00392                 // change the file name of the displacement map
+00393                 tileBank2.getTileSet(_tileSet)->setDisplacement ((CTileSet::TDisplacement)tile, troncated);
+00394 
+00395                 // not loaded
+00396                 theListDisplacement[tile].loaded=0;
+00397 
+00398                 // load it
+00399                 if (name!="")
+00400                 {
+00401                         if (!_LoadBitmap(tileBank2.getAbsPath() + name, &theListDisplacement[tile].BmpInfo, theListDisplacement[tile].Bits, NULL, 0))
+00402                                 MessageBox (NULL, (tileBank2.getAbsPath() + name).c_str(), "Can't load file", MB_OK|MB_ICONEXCLAMATION);
+00403                         else
+00404                                 theListDisplacement[tile].loaded=1;
+00405                 }
+00406         }
+00407         else
+00408         {
+00409                 // Error: bitmap not in the absolute path..
+00410                 char msg[512];
+00411                 sprintf (msg, "The bitmap %s is not in the absolute path %s.", name.c_str(), tileBank2.getAbsPath ().c_str());
+00412                 MessageBox (NULL, msg, "Load error", MB_OK|MB_ICONEXCLAMATION);
+00413         }
+00414 
+00415         return 1;
+00416 }
+00417 
+00418 int TileList::setTileTransitionAlpha (int tile, const std::string& name, int rot)
+00419 {
+00420         // Remove the absolute path from the path name
+00421         std::string troncated=name;
+00422         if (RemovePath (troncated, tileBank2.getAbsPath ().c_str()))
+00423         {
+00424                 vector<NLMISC::CBGRA> tampon;
+00425                 uint Width;
+00426                 uint Height;
+00427                 if (!PIC_LoadPic(tileBank2.getAbsPath ()+troncated, tampon, Width, Height))
+00428                 {
+00429                         MessageBox (NULL, (tileBank2.getAbsPath ()+troncated).c_str(), "Can't load bitmap.", MB_OK|MB_ICONEXCLAMATION);
+00430                         return 0;
+00431                 }
+00432                 else
+00433                 {
+00434                         CTileBorder border;
+00435                         border.set (Width, Height, tampon);
+00436 
+00437                         // rotate the border
+00438                         int rotBis=rot;
+00439                         while (rotBis)
+00440                         {
+00441                                 border.rotate ();
+00442                                 rotBis--;
+00443                         }
+00444                         
+00445                         CTileSet::TError error;
+00446                         int indexError;
+00447                         int pixel=-1;
+00448                         int composante=4;
+00449                         if (((error=tileBank2.getTileSet(_tileSet)->checkTileTransition ((CTileSet::TTransition)tile, CTile::alpha, border, indexError,
+00450                                 pixel, composante))!=CTileSet::ok)&&!zouille ())
+00451                         {
+00452                                 char sMsg[512];
+00453                                 if ((error==CTileSet::topInterfaceProblem)||(error==CTileSet::bottomInterfaceProblem)||(error==CTileSet::leftInterfaceProblem)
+00454                                         ||(error==CTileSet::rightInterfaceProblem)||(error==CTileSet::topBottomNotTheSame)||(error==CTileSet::rightLeftNotTheSame)
+00455                                         ||(error==CTileSet::topInterfaceProblem))
+00456                                 {
+00457                                         static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
+00458                                         if (indexError!=-1)
+00459                                                 sprintf (sMsg, "%s\nIncompatible with tile n�%d\nPixel: %d (%s)", CTileSet::getErrorMessage (error), indexError,
+00460                                                         pixel, comp[composante]);
+00461                                         else
+00462                                                 sprintf (sMsg, "%s\nIncompatible with the 128x128 tile\nPixel: %d (%s)", CTileSet::getErrorMessage (error),
+00463                                                         pixel, comp[composante]);
+00464                                 }
+00465                                 else
+00466                                         sprintf (sMsg, "%s\nIncompatible filled tile", CTileSet::getErrorMessage (error));
+00467                                 MessageBox (NULL, sMsg, "Can't add tile", MB_OK|MB_ICONEXCLAMATION);
+00468                                 return 0;
+00469                         }
+00470                         else
+00471                         {
+00472                                 tileBank2.getTileSet(_tileSet)->setTileTransitionAlpha ((CTileSet::TTransition)tile, troncated, tileBank2, border, rot);
+00473                                 theListTransition[tile].alphaLoaded=0;
+00474                                 theListTransition[tile].Load (tileBank2.getTileSet(_tileSet)->getTransition(tile)->getTile(), NULL);
+00475                         }
+00476                 }
+00477         }
+00478         else
+00479         {
+00480                 // Error: bitmap not in the absolute path..
+00481                 char msg[512];
+00482                 sprintf (msg, "The bitmap %s is not in the absolute path %s.", name.c_str(), tileBank2.getAbsPath ().c_str());
+00483                 MessageBox (NULL, msg, "Load error", MB_OK|MB_ICONEXCLAMATION);
+00484         }
+00485 
+00486         return 1;
+00487 }
+00488 
+00489 void TileList::removeTile128 (int index)
+00490 {
+00491         tileBank2.getTileSet (_tileSet)->removeTile128 (index, tileBank2);
+00492         theList[0].erase (theList[0].begin()+index);
+00493         for (int i=0; i<(sint)theList[0].size(); i++)
+00494         {
+00495                 theList[0][i].id=i;
+00496         }
+00497 }
+00498 
+00499 void TileList::removeTile256 (int index)
+00500 {
+00501         tileBank2.getTileSet (_tileSet)->removeTile256 (index, tileBank2);
+00502         theList[1].erase (theList[1].begin()+index);
+00503         for (int i=0; i<(sint)theList[1].size(); i++)
+00504         {
+00505                 theList[1][i].id=i;
+00506         }
+00507 }
+00508 
+00509 void TileList::clearTile128 (int index, CTile::TBitmap bitmap)
+00510 {
+00511         switch (bitmap)
+00512         {
+00513         case CTile::diffuse:
+00514                 theList128[index].loaded=0;
+00515                 theList128[index].Bits.resize(0);
+00516                 break;
+00517         case CTile::additive:
+00518                 theList128[index].nightLoaded=0;
+00519                 theList128[index].nightBits.resize(0);
+00520                 break;
+00521         case CTile::alpha:
+00522                 theList128[index].alphaLoaded=0;
+00523                 theList128[index].alphaBits.resize(0);
+00524                 break;
+00525         }
+00526         tileBank2.getTileSet (_tileSet)->clearTile128 (index, bitmap, tileBank2);
+00527 }
+00528 
+00529 void TileList::clearTile256 (int index, CTile::TBitmap bitmap)
+00530 {
+00531         switch (bitmap)
+00532         {
+00533         case CTile::diffuse:
+00534                 theList256[index].loaded=0;
+00535                 theList256[index].Bits.resize(0);
+00536                 break;
+00537         case CTile::additive:
+00538                 theList256[index].nightLoaded=0;
+00539                 theList256[index].nightBits.resize(0);
+00540                 break;
+00541         case CTile::alpha:
+00542                 theList256[index].alphaLoaded=0;
+00543                 theList256[index].alphaBits.resize(0);
+00544                 break;
+00545         }
+00546         tileBank2.getTileSet (_tileSet)->clearTile256 (index, bitmap, tileBank2);
+00547 }
+00548 
+00549 void TileList::clearTransition (int index, CTile::TBitmap bitmap)
+00550 {
+00551         switch (bitmap)
+00552         {
+00553         case CTile::diffuse:
+00554                 theListTransition[index].loaded=0;
+00555                 theListTransition[index].Bits.resize(0);
+00556                 break;
+00557         case CTile::additive:
+00558                 theListTransition[index].nightLoaded=0;
+00559                 theListTransition[index].nightBits.resize(0);
+00560                 break;
+00561         case CTile::alpha:
+00562                 theListTransition[index].alphaLoaded=0;
+00563                 theListTransition[index].alphaBits.resize(0);
+00564                 break;
+00565         }
+00566         tileBank2.getTileSet (_tileSet)->clearTransition ((CTileSet::TTransition)index, bitmap, tileBank2);
+00567 }
+00568 
+00569 void TileList::clearDisplacement (int index)
+00570 {
+00571         // Clear the displacement map filename
+00572         tileBank2.getTileSet (_tileSet)->clearDisplacement ((CTileSet::TDisplacement)index);
+00573 }
+00574 
+00575 tilelist::iterator TileList::GetFirst(int n)
+00576 {
+00577         //UpdateLF();
+00578         return theList[n].begin();
+00579 }
+00580 
+00581 tilelist::iterator TileList::GetLast(int n)
+00582 {
+00583         //UpdateLF();
+00584         return theList[n].end();
+00585 }
+00586 
+00587 int TileList::GetSize(int n)
+00588 {
+00589         //UpdateLF();
+00590         return theList[n].size();
+00591 }
+00592 
+00593 void TileInfo::Delete ()
+00594 {
+00595         loaded=0;
+00596         nightLoaded=0;
+00597         alphaLoaded=0;
+00598 }
+00599 
+00600 
+00601 tilelist::iterator TileList::Get(int i, int n)
+00602 {
+00603         return theList[n].begin()+i;
+00604 }
+00605 
+00606 const std::string& TileInfo::getRelativeFileName (CTile::TBitmap type, int index)
+00607 {
+00608         return tileBank2.getTile (index)->getRelativeFileName (type);
+00609 }
+00610 
+00611 bool TileInfo::Load (int index, std::vector<NLMISC::CBGRA>* Alpha)
+00612 {
+00613         bool bRes=true;
+00614         if (!loaded && getRelativeFileName (CTile::diffuse, index)!="")
+00615         {
+00616                 if (!_LoadBitmap(tileBank2.getAbsPath() + getRelativeFileName (CTile::diffuse, index), &BmpInfo, Bits, Alpha, 0))
+00617                 {
+00618                         bRes=false;
+00619                         MessageBox (NULL, (tileBank2.getAbsPath() + getRelativeFileName (CTile::diffuse, index)).c_str(), "Can't load file", MB_OK|MB_ICONEXCLAMATION);
+00620                 }
+00621                 else
+00622                         loaded=1;
+00623         }
+00624         if (!nightLoaded && getRelativeFileName (CTile::additive, index)!="")
+00625         {
+00626                 if (!_LoadBitmap(tileBank2.getAbsPath() + getRelativeFileName (CTile::additive, index), &nightBmpInfo, nightBits, Alpha, 0))
+00627                 {
+00628                         bRes=false;
+00629                         MessageBox (NULL, (tileBank2.getAbsPath() + getRelativeFileName (CTile::additive, index)).c_str(), "Can't load file", MB_OK|MB_ICONEXCLAMATION);
+00630                 }
+00631                 else
+00632                         nightLoaded=1;
+00633         }
+00634         if (!alphaLoaded && getRelativeFileName (CTile::alpha, index)!="")
+00635         {
+00636                 if (!_LoadBitmap(tileBank2.getAbsPath() + getRelativeFileName (CTile::alpha, index), &alphaBmpInfo, alphaBits, NULL, 
+00637                         tileBank2.getTile (index)->getRotAlpha ()))
+00638                 {
+00639                         bRes=false;
+00640                         MessageBox (NULL, (tileBank2.getAbsPath() + getRelativeFileName (CTile::alpha, index)).c_str(), "Can't load file", MB_OK|MB_ICONEXCLAMATION);
+00641                 }
+00642                 else
+00643                         alphaLoaded=1;
+00644         }
+00645         return bRes;
+00646 }
+00647 
+00648 void TileList::Reload(int first, int count, int n) //recharge en memoire une tranche de tiles
+00649 {
+00650         for (int i=first; i<count; i++)
+00651         {
+00652                 switch (n)
+00653                 {
+00654                 case 0:
+00655                         theList[n][i].Load (tileBank2.getTileSet(_tileSet)->getTile128 (i), NULL);
+00656                         break;
+00657                 case 1:
+00658                         theList[n][i].Load (tileBank2.getTileSet(_tileSet)->getTile256 (i), NULL);
+00659                         break;
+00660                 case 2:
+00661                         {
+00662                                 int index=tileBank2.getTileSet(_tileSet)->getTransition (i)->getTile();
+00663                                 if (index!=-1)
+00664                                         theList[n][i].Load (index, &theListTransition[i].alphaBits);
+00665                         }
+00666                         break;
+00667                 }
+00668         }
+00669 }
+00670 
+00671 //CTView
+00672 CTView::CTView()
+00673 {
+00674         sizetile_x = SIZE_SMALL; sizetile_y = SIZE_SMALL;
+00675         sizetext_y = 14;
+00676         spacing_x = SPACING_SMALL_X; spacing_y = SPACING_SMALL_Y; 
+00677         Zoom=3; Texture = 1; Sort = 1; InfoTexte = 1;
+00678         count_ = 0; ViewTileMode = 0;
+00679         scrollpos = 0; lastVBarPos = 0;
+00680         smEdgeList = 0; bPopup = 0;
+00681         //theViewPopup = 0;
+00682 }
+00683 
+00684 CTView::~CTView()
+00685 {
+00686 }
+00687 
+00688 void CTView::Init(int _land, int n)
+00689 {       
+00690         InfoList._tileSet=_land;
+00691         UpdateSize(n);
+00692         pipo_buffer = (void *)new char[sizetile_x * sizetile_y * 3];
+00693         bmp = new CBitmap;
+00694         bmp->CreateBitmap(sizetile_x,sizetile_y,1,24,pipo_buffer);
+00695         pImList = new CImageList;
+00696         pImList->Create(sizetile_x,sizetile_y,ILC_COLOR24,0,1);
+00697         pImList->Add(bmp,(CBitmap*)NULL);
+00698         char *defautpath = ((SelectionTerritoire*)GetParent()->GetParent())->DefautPath.GetBuffer(256);
+00699         count_=1;
+00700 }
+00701 
+00702 void CTView::Delete()
+00703 {
+00704         count_=0; pImList = 0;
+00705 }
+00706 
+00707 int CTView::GetNbTileLine(void)
+00708 {
+00709         RECT rect; GetClientRect(&rect);
+00710         return (max (1, (rect.right - rect.left - spacing_x)/(sizeicon_x + spacing_x)));
+00711 }
+00712 
+00713 int CTView::GetNbTileColumn(void)
+00714 {
+00715         RECT rect; GetClientRect(&rect);
+00716         int deb;
+00717         if (scrollpos<spacing_y) deb = -scrollpos;
+00718         else deb = (scrollpos - spacing_y)%(sizeicon_y + spacing_y);
+00719         if (deb>sizeicon_y) deb -=sizeicon_y + spacing_y;
+00720         int ret= ((rect.bottom - rect.top /*- spacing_y*/ + deb)/(sizeicon_y + spacing_y)) +1 ;
+00721         return max (1, ret);
+00722 }
+00723 
+00724 void CTView::GetVisibility(int &First,int &Last, int n) //retourne l'indice du premier et du dernier item visible dans la fenetre
+00725 {
+00726         int y;
+00727         int i = GetNbTileLine(); int j = GetNbTileColumn();
+00728         if (scrollpos<spacing_y) y = 0;
+00729         else y = (scrollpos - spacing_y)%(sizeicon_y + spacing_y);
+00730         First = ((scrollpos - spacing_y)/(sizeicon_y + spacing_y));
+00731         if (y>sizeicon_y) First++;
+00732         First *= i;
+00733         Last = First + i*j -1;
+00734         if (InfoList.GetSize(n)>0 && Last>=InfoList.GetSize(n)) Last = InfoList.GetSize(n)-1;
+00735         if (First>Last) First = Last;
+00736 }
+00737 
+00738 int CTView::GetIndex(LPPOINT pt, int n) //retourne l'index d'un incone a partir de sa position dans le fenetre
+00739 //si le curseur n'est pas sur un icon, retourne -1
+00740 {
+00741         POINT pts = *pt;
+00742         pts.y += scrollpos;
+00743         RECT rect; GetClientRect(&rect);
+00744         int i = GetNbTileLine();
+00745         int lf = (rect.right - rect.left) - (GetNbTileLine()*(spacing_x+sizeicon_x) + spacing_x);
+00746         if (pts.x > (rect.right - rect.left - lf)) return -1;
+00747         if (pts.x<0) return -1;
+00748         if (pts.y<spacing_y) return -1;
+00749         int y = (pts.y - spacing_y)%(spacing_y + sizeicon_y);
+00750         if (y>sizeicon_y) return -1;
+00751         int il = (pts.y - spacing_y)/(spacing_y + sizeicon_y);
+00752         int x = (pts.x - spacing_x)%(spacing_x + sizeicon_x);
+00753         if (x>sizeicon_x) return -1;
+00754         int ic = (pts.x - spacing_x)/(spacing_x + sizeicon_x);
+00755         int ret = ic + il*i;
+00756         if (ret<InfoList.GetSize(n) && ret>=0) return ret;
+00757         else return -1;
+00758 }
+00759 
+00760 POINT CTView::GetPos(int i) //fonction inverse de GetIndex
+00761 {
+00762         POINT ret;
+00763         int nl = max (1, GetNbTileLine());
+00764         ret.x = (i%nl)*(spacing_x + sizeicon_x) + spacing_x;
+00765         ret.y = (i/nl)*(spacing_y + sizeicon_y) + spacing_y - scrollpos;        
+00766         return ret;
+00767 }
+00768 
+00769 void CTView::UpdateSelection(LPRECT rect_,int mode, int n) //rect : coordonnees du rectangle de selection dans la fenetre parent
+00770 {       
+00771         RECT client,*rect; GetWindowRect(&client);
+00772         rect = new RECT; memcpy(rect,rect_,sizeof(RECT));
+00773         //on se met dans le repere de CTView
+00774         POINT pt; pt.x = rect->left; pt.y = rect->top;
+00775         GetParent()->ClientToScreen(&pt);
+00776         ScreenToClient(&pt);
+00777         rect->left = pt.x;
+00778         rect->top = pt.y;       
+00779         pt.x = rect->right; pt.y = rect->bottom;
+00780         GetParent()->ClientToScreen(&pt);
+00781         ScreenToClient(&pt);
+00782         rect->right = pt.x;
+00783         rect->bottom = pt.y;
+00784         rect->top += scrollpos; rect->bottom += scrollpos;
+00785 
+00786         if (rect->left<300)
+00787         {
+00788                 int toto = 0;
+00789         }
+00790 
+00791         //on clip
+00792         if (rect->left<0) rect->left = 0;
+00793         if (rect->top<scrollpos) rect->top = scrollpos;
+00794         int lf = (client.right - client.left) - (GetNbTileLine()*(spacing_x+sizeicon_x) + spacing_x);
+00795         if (rect->right>(client.right-client.left-spacing_x-lf)) 
+00796         {
+00797                 rect->right = client.right - client.left - spacing_x - lf;
+00798         }
+00799         if ((rect->bottom-scrollpos)>(client.bottom-client.top)) rect->bottom=client.bottom-client.top+scrollpos;       
+00800         
+00801         if (rect->left<spacing_x) rect->left = spacing_x;
+00802         if ((rect->top-scrollpos)<spacing_y) rect->top = spacing_y + scrollpos;
+00803         int rx = (rect->left - spacing_x)%(spacing_x + sizeicon_x);
+00804         rect->left -= rx;
+00805         if (rx>=sizeicon_x)
+00806         {
+00807                 rect->left += sizeicon_x + spacing_x;
+00808                 if (rect->left>=(client.right - client.left)) rect->left = (client.right - client.left) - spacing_x;
+00809         }
+00810         int ry = (rect->top - spacing_y)%(spacing_y + sizeicon_y);
+00811         rect->top -= ry;
+00812         if (ry>=sizeicon_y)
+00813         {
+00814                 rect->top += sizeicon_y + spacing_y;
+00815                 if ((rect->top-scrollpos)>=(client.bottom - client.top)) rect->top = (client.bottom - client.top) - spacing_y + scrollpos;
+00816         }
+00817 
+00818         
+00819         if (rect->right<spacing_x || (rect->bottom-scrollpos)<spacing_y) return;
+00820         rx = (rect->right - spacing_x)%(spacing_x + sizeicon_x);
+00821         rect->right += (sizeicon_x - rx -1 );
+00822         ry = (rect->bottom - spacing_y)%(spacing_y + sizeicon_y);
+00823         rect->bottom += (sizeicon_y - ry -1 );
+00824 
+00825         if (rect->bottom<rect->top || rect->left>rect->right) return;
+00826         pt; pt.x = rect->left; pt.y = rect->top; pt.y -=scrollpos;
+00827         int index = GetIndex(&pt, n);
+00828         tilelist::iterator p = InfoList.GetFirst(n);    
+00829         CDC *pDC = GetDC();
+00830         if (index==-1 && !(mode&MK_SHIFT))
+00831         {
+00832                 for (int i = 0;i<InfoList.GetSize(n); i++)
+00833                 {
+00834                         if (p->Selected==1)
+00835                         {
+00836                                 p->Selected = 0;
+00837                                 DrawTile(p,pDC,0,n);
+00838                         }
+00839                         p++;
+00840                 }
+00841                 if (pDC) 
+00842                         ::ReleaseDC(*this,*pDC);
+00843                 return;
+00844         }
+00845         for (int i = 0;i<index;i++) 
+00846         {
+00847                 if (p==InfoList.GetLast(n))
+00848                 {
+00849                         if (pDC!=NULL) 
+00850                                 ::ReleaseDC(*this,*pDC);
+00851                         return;
+00852                 }
+00853                 if (p->Selected==1) 
+00854                 {
+00855                         p->Selected = 0;
+00856                         DrawTile(p,pDC,0,n);
+00857                 }
+00858                 else if (p->Selected&4)
+00859                 {
+00860                         if (p->Selected) p->Selected=2;
+00861                         else p->Selected = 3;
+00862                         DrawTile(p,pDC,0,n);
+00863                 }
+00864                 p++;
+00865         }
+00866         int nbline = GetNbTileLine();
+00867         int incd = index%nbline;
+00868         for (int j = rect->top;j<=rect->bottom;j+=sizeicon_y + spacing_y)
+00869         {
+00870                 int k = 0;
+00871                 if (j!=rect->top)
+00872                 {
+00873                         for (;k<incd;k++) 
+00874                         {
+00875                                 if (p==InfoList.GetLast(n))
+00876                                 {
+00877                                         if (pDC!=NULL) 
+00878                                                 ::ReleaseDC(*this,*pDC);
+00879                                         return;
+00880                                 }
+00881                                 if (p->Selected==1)
+00882                                 {
+00883                                         p->Selected = 0; 
+00884                                         DrawTile(p,pDC,0,n);
+00885                                 }                               
+00886                                 else if (p->Selected&4)
+00887                                 {
+00888                                         if (p->Selected&3) p->Selected=2;
+00889                                         else p->Selected = 3;
+00890                                         int k = !(p->Selected&1);
+00891                                         DrawTile(p,pDC,0,n);
+00892                                 }
+00893                                 p++;
+00894                         }
+00895                 }
+00896                 else k = incd;
+00897                 for (int i = rect->left;i<=rect->right;i+=sizeicon_x + spacing_x)
+00898                 {
+00899                         if (p==InfoList.GetLast(n)) 
+00900                         {
+00901                                 if (pDC!=NULL) 
+00902                                         ::ReleaseDC(*this,*pDC);
+00903                                 return;
+00904                         }
+00905                         if (!(mode&MK_CONTROL))
+00906                         {
+00907                                 if (p->Selected!=1)
+00908                                 {
+00909                                         p->Selected = 1;
+00910                                         DrawTile(p,pDC,0,n);
+00911                                 }
+00912                         }
+00913                         else
+00914                         {                               
+00915                                 if ((p->Selected&4)==0)
+00916                                 {
+00917                                         int k = p->Selected;
+00918                                         p->Selected = (p->Selected&3)?4:5;                              
+00919                                         k = p->Selected;
+00920                                         DrawTile(p,pDC,0,n);
+00921                                 }
+00922                         }
+00923                         p++;
+00924                         k++;
+00925                 }
+00926                 for (;k<nbline;k++) 
+00927                 {
+00928                         if (p==InfoList.GetLast(n)) 
+00929                         {
+00930                                 if (pDC!=NULL) 
+00931                                         ::ReleaseDC(*this,*pDC);
+00932                                 return;
+00933                         }
+00934                         if (p->Selected==1) 
+00935                         {
+00936                                 p->Selected = 0; 
+00937                                 DrawTile(p,pDC,0,n);
+00938                         } 
+00939                         else if (p->Selected&4)
+00940                         {
+00941                                 if (p->Selected&3) p->Selected=2;
+00942                                 else p->Selected = 3;
+00943                                 DrawTile(p,pDC,0,n);
+00944                         }
+00945                         p++;
+00946                 }
+00947         }
+00948         for (;p!=InfoList.GetLast(n);p++) 
+00949         {
+00950                 if (p->Selected==1) 
+00951                 {
+00952                         p->Selected = 0;
+00953                         DrawTile(p,pDC,0,n);
+00954                 }
+00955                 else if (p->Selected&4)
+00956                 {
+00957                         if (p->Selected&3) p->Selected=2;
+00958                         else p->Selected = 3;
+00959                         DrawTile(p,pDC,0,n);
+00960                 }
+00961         }
+00962         if (pDC!=NULL) 
+00963                 ::ReleaseDC(*this,*pDC);
+00964 }
+00965                 
+00966 void CTView::DeleteTile(tilelist::iterator p)
+00967 {
+00968         p->loaded = 0;
+00969         p->nightLoaded = 0;
+00970         p->alphaLoaded = 0;
+00971 }
+00972 
+00973 void CTView::UpdateBar(int iFirst,int iLast, int n)
+00974 {
+00975         int i = GetNbTileColumn(); 
+00976         int j = max (1, GetNbTileLine());
+00977         int nbline = InfoList.GetSize(n)/j+1;
+00978         int posline = iFirst/j;
+00979         SCROLLINFO scr;
+00980         scr.fMask = SIF_ALL ^ SIF_POS;
+00981         scr.nMin = 0; scr.nMax = SCROLL_MAX; 
+00982         if (nbline==0) {scr.nPage = SCROLL_MAX; scr.nPos = 0;}
+00983         else 
+00984         {
+00985                 scr.nPage = (SCROLL_MAX*i)/nbline;
+00986         }
+00987         GetParent()->SetScrollInfo(SB_VERT,&scr);
+00988 }
+00989         
+00990 
+00991 
+00992 
+00993 int CTView::IsSelected(int i)
+00994 {
+00995         return 0;
+00996 }
+00997 
+00998 void CTView::UpdateSize(int n)
+00999 {
+01000         spacing_tile_text = 3;
+01001         if (Zoom==1) {sizetile_x = sizetile_y = SIZE_SMALL; spacing_x = SPACING_SMALL_X; spacing_y = SPACING_SMALL_Y;}
+01002         if (Zoom==2) {sizetile_x = sizetile_y = SIZE_NORMAL; spacing_x = SPACING_NORMAL_X; spacing_y = SPACING_NORMAL_Y;}
+01003         if (Zoom==3) {sizetile_x = sizetile_y = SIZE_BIG; spacing_x = SPACING_BIG_X; spacing_y = SPACING_BIG_Y;}
+01004         if (n==1)
+01005         {
+01006                 sizetile_x *= 2;
+01007                 sizetile_y *= 2;
+01008         }
+01009         sizeicon_x = sizetile_x; sizeicon_y = sizetile_y + sizetext_y + spacing_tile_text;
+01010 }
+01011 
+01012 int debug = 0;
+01013 
+01014 void CTView::OnPaint() 
+01015 {
+01016         Browse *parent = (Browse*)this->GetParent();
+01017         CPaintDC dc(this); // device context for painting
+01018         // TODO: Add your message handler code here
+01019         RECT rect; GetClientRect(&rect);        
+01020         CBrush brush (GetSysColor(COLOR_3DFACE));
+01021         
+01022         
+01023         dc.FillRect(&rect,&brush);
+01024         
+01025         if (InfoList.GetSize(parent->m_128x128)==0) return;
+01026         
+01027         debug=(debug+1)&1;
+01028 
+01029         if (debug==1)
+01030         {
+01031                 debug = 1;
+01032         }
+01033 
+01034         CRgn clip;
+01035         clip.CreateRectRgn(rect.left,rect.top,rect.right,rect.bottom);
+01036         dc.SelectClipRgn(&clip);
+01037         
+01038         CRgn update;
+01039         if (GetUpdateRgn(&update)==NULLREGION)
+01040         {
+01041                 ::ReleaseDC(*this,dc);
+01042                 return;
+01043         }
+01044 
+01045         GetVisibility(iFV, iLV, parent->m_128x128);
+01046         UpdateBar(iFV, iLV, parent->m_128x128);
+01047         if (!normal_font) 
+01048         {
+01049                 normal_font = new CFont;
+01050                 normal_font->CreateFont(-10,0,0,0,FW_THIN,false,false,false,DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,FIXED_PITCH,NULL);
+01051         }
+01052         
+01053         tilelist::iterator p = InfoList.GetFirst(parent->m_128x128);
+01054         for (int i=0;i<iFV;i++) p++;
+01055         for (i=iFV;i<=iLV;i++) 
+01056                 DrawTile(p++,&dc,0, parent->m_128x128);
+01057         ::ReleaseDC (*this, dc);
+01058 }
+01059 
+01060 void CTView::OnDropFiles(HDROP hDropInfo) 
+01061 {
+01062         // TODO: Add your message handler code here and/or call default
+01063         //first : on verifie s'il les tiles doivent etre inseres
+01064         if (!lockInsertion)
+01065         {
+01066                 Browse *parent = (Browse*)this->GetParent();
+01067                 char FileName[256];
+01068                 int count=DragQueryFile(hDropInfo,0xffffffff,FileName,256); //count = nombre de fichiers dans le drop
+01069                 
+01070 
+01071                 POINT pos;
+01072                 DragQueryPoint(hDropInfo,&pos); //retrieve cursor position
+01073                 CDC *pDC = GetDC();
+01074                 for (int i=0;i<count;i++) 
+01075                 {
+01076                         DragQueryFile(hDropInfo,i,FileName,256);
+01077                         switch (parent->m_128x128)
+01078                         {
+01079                         case 0:
+01080                                 {
+01081                                         int index=InfoList.addTile128 ();
+01082                                         if (InfoList.setTile128 (index, FileName, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha)))
+01083                                         {
+01084                                                 tilelist::iterator it = InfoList.GetLast(parent->m_128x128);
+01085                                                 it--;
+01086                                         }
+01087                                         else
+01088                                         {
+01089                                                 InfoList.removeTile128 (index);
+01090                                         }
+01091                                 }
+01092                                 break;
+01093                         case 1:
+01094                                 {
+01095                                         int index=InfoList.addTile256 ();
+01096                                         if (InfoList.setTile256 (index, FileName, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha)))
+01097                                         {
+01098                                                 tilelist::iterator it = InfoList.GetLast(parent->m_128x128);
+01099                                                 it--;
+01100                                         }
+01101                                         else
+01102                                                 InfoList.removeTile256 (index);
+01103                                 }
+01104                                 break;
+01105                         case 2:
+01106                                 {
+01107                                 }
+01108                                 break;
+01109                         }
+01110                 }
+01111                 
+01112                 int iFV,iLV;
+01113                 GetVisibility(iFV, iLV, parent->m_128x128);
+01114                 UpdateBar(iFV, iLV, parent->m_128x128);
+01115                 Invalidate ();
+01116         }
+01117         CStatic::OnDropFiles(hDropInfo);
+01118 }
+01119 
+01120 void CTView::DrawTile(tilelist::iterator i,CDC *pDC,int clear, int n)
+01121 {
+01122         RECT rect; GetClientRect(&rect);        
+01123         CBrush brush (GetSysColor(COLOR_3DFACE));
+01124         if (InfoList.GetSize(n)==0) 
+01125         {
+01126                 return;
+01127         }
+01128 
+01129         LPBITMAPINFO bmpinf;
+01130         std::string pth; 
+01131         std::vector<NLMISC::CBGRA> *bits;
+01132         int loaded;
+01133 
+01134         switch (n)
+01135         {
+01136         case 0:
+01137                 pth = i->getRelativeFileName ((CTile::TBitmap)(Texture-1), tileBank2.getTileSet (InfoList._tileSet)->getTile128 (i->id));
+01138                 break;
+01139         case 1:
+01140                 pth = i->getRelativeFileName ((CTile::TBitmap)(Texture-1), tileBank2.getTileSet (InfoList._tileSet)->getTile256 (i->id));
+01141                 break;
+01142         case 2:
+01143                 {
+01144                         int index=tileBank2.getTileSet (InfoList._tileSet)->getTransition (i->id)->getTile();
+01145                         if (index!=-1)
+01146                                 pth = i->getRelativeFileName ((CTile::TBitmap)(Texture-1), index);
+01147                         else
+01148                                 pth = "";
+01149                 }
+01150                 break;
+01151         case 3:
+01152                 pth = tileBank2.getTileSet (InfoList._tileSet)->getDisplacementFileName ((CTileSet::TDisplacement)i->id);
+01153                 break;
+01154         }
+01155 
+01156         switch(Texture)
+01157         {
+01158                 case 1:
+01159                         bmpinf = &(i->BmpInfo);
+01160                         bits = &i->Bits;
+01161                         loaded = i->loaded;
+01162                         break;
+01163                 case 2:
+01164                         bmpinf = &(i->nightBmpInfo);
+01165                         bits = &i->nightBits;
+01166                         loaded = i->nightLoaded;
+01167                         break;
+01168                 case 3:
+01169                         bmpinf = &(i->alphaBmpInfo);
+01170                         bits = &i->alphaBits;
+01171                         loaded = i->alphaLoaded;
+01172                         break;
+01173         }
+01174 
+01175         CRgn clip;
+01176         clip.CreateRectRgn(rect.left,rect.top,rect.right,rect.bottom);
+01177         pDC->SelectClipRgn(&clip);
+01178         
+01179         // Select a font
+01180         CFont *pOldFont=pDC->SelectObject(normal_font);
+01181         
+01182         POINT pt;
+01183         pt = GetPos(i->id);
+01184         RECT rect_txt; 
+01185         rect_txt.top = pt.y;
+01186         rect_txt.bottom = pt.y + sizeicon_y + spacing_y;
+01187         rect_txt.left = pt.x; rect_txt.right = pt.x + sizeicon_x + spacing_x;
+01188 
+01189         // Turn every other pixel to black
+01190         COLORREF clrBk = pDC->SetBkColor( GetSysColor(COLOR_3DFACE) );
+01191         COLORREF clrText = pDC->SetTextColor( RGB(0,0,0) );
+01192         
+01193         if (clear) pDC->FillRect(&rect_txt,&brush);
+01194         
+01195         if (!loaded)
+01196         {
+01197                 pDC->FillSolidRect( pt.x, pt.y, sizetile_x, sizetile_y, GetSysColor(COLOR_3DFACE) );
+01198                 pDC->MoveTo (pt.x,pt.y);
+01199                 pDC->LineTo (pt.x+sizetile_x,pt.y+sizetile_y);
+01200                 pDC->MoveTo (pt.x+sizetile_x,pt.y);
+01201                 pDC->LineTo (pt.x,pt.y+sizetile_y);
+01202                 pDC->MoveTo (pt.x,pt.y);
+01203                 pDC->LineTo (pt.x+sizetile_x,pt.y);
+01204                 pDC->LineTo (pt.x+sizetile_x,pt.y+sizetile_y);
+01205                 pDC->LineTo (pt.x,pt.y+sizetile_y);
+01206                 pDC->LineTo (pt.x,pt.y);
+01207 
+01208                 pDC->MoveTo (pt.x+1,pt.y);
+01209                 pDC->LineTo (pt.x+sizetile_x,pt.y+sizetile_y-1);
+01210                 pDC->MoveTo (pt.x,pt.y+1);
+01211                 pDC->LineTo (pt.x+sizetile_x-1,pt.y+sizetile_y);
+01212                 
+01213                 pDC->MoveTo (pt.x+sizetile_x-1,pt.y);
+01214                 pDC->LineTo (pt.x,pt.y+sizetile_y-1);
+01215                 pDC->MoveTo (pt.x+sizetile_x,pt.y+1);
+01216                 pDC->LineTo (pt.x+1,pt.y+sizetile_y);
+01217         }
+01218         else
+01219         {
+01220                 StretchDIBits(pDC->m_hDC,pt.x,pt.y,
+01221                         sizetile_x,sizetile_y,0,0,
+01222                         bmpinf->bmiHeader.biWidth,
+01223                         -bmpinf->bmiHeader.biHeight,
+01224                         &*bits->begin(),bmpinf,DIB_RGB_COLORS,SRCCOPY);
+01225         }
+01226                         
+01227         char temp[100];
+01228         char Name[256]; Name[0] = 0;
+01229         if (InfoTexte==2)
+01230         {
+01231                 _splitpath(pth.c_str(),temp,temp,Name,temp);            
+01232         }
+01233         else if (InfoTexte==3)
+01234         {
+01235                 __int64 mask = 1;
+01236         }
+01237         else if (InfoTexte==1)
+01238         {
+01239                 sprintf(Name,"%d",i->id);
+01240         }
+01241         rect_txt.top = pt.y + sizetile_y + spacing_tile_text;
+01242         rect_txt.bottom += rect_txt.top + sizetext_y;
+01243         rect_txt.left -= spacing_x;
+01244         pDC->DrawText(Name,strlen(Name),&rect_txt,DT_CENTER | DT_SINGLELINE);
+01245 
+01246         // Restore the device context
+01247         pDC->SetBkColor( clrBk );
+01248         pDC->SetTextColor( clrText );
+01249 
+01250         if (i->Selected&3)
+01251         {
+01252                 CRect rc;
+01253                 rc.left = pt.x; rc.top = pt.y; rc.right = rc.left + sizetile_x; rc.bottom = rc.top + sizetile_y;
+01254                 ShadeRect(pDC,rc);
+01255         }
+01256 
+01257         // Invalidate flag button
+01258         Browse *parent = (Browse*)this->GetParent();
+01259         parent->UpdateFlags ();
+01260 
+01261         // Release the font
+01262         pDC->SelectObject(pOldFont);
+01263 }
+01264 
+01265 void CTView::ShadeRect( CDC *pDC, CRect& rect )
+01266 
+01267 {
+01268      // Bit pattern for a monochrome brush with every
+01269      // other pixel turned off
+01270      WORD Bits[8] = { 0x0055, 0x00aa, 0x0055, 0x00aa,
+01271                       0x0055, 0x00aa, 0x0055, 0x00aa };
+01272 
+01273         CBitmap bmBrush;
+01274         CBrush brush; // (GetSysColor(COLOR_3DFACE));
+01275 
+01276         // Need a monochrome pattern bitmap
+01277         bmBrush.CreateBitmap( 8, 8, 1, 1, &Bits );
+01278 
+01279         // Create the pattern brush
+01280         brush.CreatePatternBrush( &bmBrush );
+01281 
+01282         CBrush *pOldBrush = pDC->SelectObject( &brush );
+01283 
+01284         // Turn every other pixel to black
+01285         COLORREF clrBk = pDC->SetBkColor( GetSysColor(COLOR_3DFACE) );
+01286         COLORREF clrText = pDC->SetTextColor( RGB(0,0,0) );
+01287         // 0x00A000C9 is the ROP code to AND the brush with the destination
+01288         pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), 
+01289                  (DWORD)0x00A000C9);                     //DPa - raster code
+01290 
+01291         pDC->SetBkColor( clrBk );
+01292         pDC->SetTextColor( clrText );
+01293         clrBk = pDC->SetBkColor( RGB(0,0,0) );
+01294         clrText = pDC->SetTextColor( GetSysColor(COLOR_HIGHLIGHT) );
+01295         // 0x00FA0089 is the ROP code to OR the brush with the destination
+01296         pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), 
+01297                  (DWORD)0x00FA0089);                     //DPo - raster code
+01298 
+01299         // Restore the device context
+01300         pDC->SelectObject( pOldBrush );
+01301         pDC->SetBkColor( clrBk );
+01302         pDC->SetTextColor( clrText );
+01303 }
+01304 
+01305 
+01306 //code modifie des sources des MFC =)))
+01307 void CTView::DrawDragRect(CDC *pDC,LPCRECT lpRect, SIZE size,
+01308         LPCRECT lpRectLast, SIZE sizeLast, CBrush* pBrush, CBrush* pBrushLast)
+01309 {
+01310         // first, determine the update region and select it
+01311         CRgn rgnNew;
+01312         CRgn rgnOutside, rgnInside;
+01313         CRect rect;
+01314         if (lpRect)
+01315         {
+01316                 rgnOutside.CreateRectRgnIndirect(lpRect);
+01317                 rect = *lpRect;
+01318                 rect.InflateRect(-size.cx, -size.cy);
+01319                 rect.IntersectRect(rect, lpRect);
+01320                 rgnInside.CreateRectRgnIndirect(rect);
+01321                 rgnNew.CreateRectRgn(0, 0, 0, 0);
+01322                 rgnNew.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);
+01323         }
+01324 
+01325         CBrush* pBrushOld = NULL;
+01326         if (pBrush == NULL)
+01327                 pBrush = CDC::GetHalftoneBrush();
+01328         if (pBrushLast == NULL)
+01329                 pBrushLast = pBrush;
+01330 
+01331         CRgn rgnLast, rgnUpdate;
+01332         if (lpRectLast != NULL/* && lpRect!=NULL*/)
+01333         {
+01334                 // find difference between new region and old region
+01335                 rgnLast.CreateRectRgn(0, 0, 0, 0);
+01336                 if (lpRect==NULL) rgnOutside.CreateRectRgnIndirect(lpRectLast);
+01337                 else rgnOutside.SetRectRgn(lpRectLast);
+01338                 rect = *lpRectLast;
+01339                 rect.InflateRect(-sizeLast.cx, -sizeLast.cy);
+01340                 rect.IntersectRect(rect, lpRectLast);
+01341                 if (lpRect==NULL) rgnInside.CreateRectRgnIndirect(rect);
+01342                 else rgnInside.SetRectRgn(rect);
+01343                 rgnLast.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);
+01344 
+01345                 // only diff them if brushes are the same
+01346                 if (pBrush->m_hObject == pBrushLast->m_hObject)
+01347                 {
+01348                         rgnUpdate.CreateRectRgn(0, 0, 0, 0);
+01349                         rgnUpdate.CombineRgn(&rgnLast, &rgnNew, RGN_XOR);
+01350                 }
+01351         }
+01352         if (!lpRect || (pBrush->m_hObject != pBrushLast->m_hObject && lpRectLast != NULL))
+01353         {
+01354                 // brushes are different -- erase old region first
+01355                 pDC->SelectClipRgn(&rgnLast);
+01356                 pDC->GetClipBox(&rect);
+01357                 pBrushOld = pDC->SelectObject(pBrushLast);
+01358                 pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
+01359                 pDC->SelectObject(pBrushOld);
+01360         }
+01361         // draw into the update/new region
+01362         if (lpRect)
+01363         {
+01364                 pDC->SelectClipRgn(rgnUpdate.m_hObject != NULL ? &rgnUpdate : &rgnNew);
+01365                 pDC->GetClipBox(&rect);
+01366                 pBrushOld = pDC->SelectObject(pBrush);
+01367                 pDC->PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
+01368                 pDC->SelectObject(pBrushOld);
+01369         }
+01370         pDC->SelectClipRgn(NULL);
+01371 }
+01372 
+01373 void CTView::RemoveSelection(int n)
+01374 {
+01375         for (tilelist::iterator p = InfoList.theList[n].begin();p!=InfoList.theList[n].end();++p)
+01376         {
+01377                 p->Selected = 0;
+01378         }
+01379 }
+01380 
+01381 void CTView::InsertItemInCtrlList(tilelist::iterator iFirst,tilelist::iterator iLast)
+01382 {
+01383 /*      int iItem = InfoList.GetSize();
+01384         for (tilelist::iterator i=iFirst;i!=iLast;++i)
+01385         {
+01386                 char num[10];
+01387                 sprintf(num,"%d",iItem);
+01388                 InsertItem(iItem,num,0);
+01389                 SetItemData(iItem++,(DWORD)(*i));
+01390         }*/
+01391 }
+01392 
+01393 
+01394 
+01395 LRESULT CTView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
+01396 {
+01397         // TODO: Add your specialized code here and/or call the base class
+01398         if (message==WM_MOUSEMOVE)
+01399         {
+01400                 MousePos.x = LOWORD(lParam);
+01401                 MousePos.y = HIWORD(lParam);
+01402         }
+01403         if (message==WM_DRAWITEM)
+01404         {
+01405                 int toto=0;
+01406         }
+01407         if (message==WM_CLOSE) Delete();
+01408         if (message==WM_COMMAND) //The user had selected an item on popup menu
+01409         {
+01410                 Browse *parent = (Browse*)this->GetParent();
+01411                 int id=LOWORD(wParam);
+01412                 if (id==ID_MENU_SUPR_TILE)
+01413                 {
+01414                         for (int i=0; i<InfoList.GetSize(parent->m_128x128); i++)
+01415                         {
+01416                                 if (InfoList.Get(i, parent->m_128x128)->Selected)
+01417                                 {
+01418                                         switch (parent->m_128x128)
+01419                                         {
+01420                                         case 0:
+01421                                                 InfoList.removeTile128 (i);
+01422                                                 break;
+01423                                         case 1:
+01424                                                 InfoList.removeTile256 (i);
+01425                                                 break;
+01426                                         default:
+01427                                                 nlassert (0); // no!
+01428                                         }
+01429                                 }
+01430                         }
+01431                         bPopup = 0;
+01432                 }
+01433                 else if (id==ID_MENU_SUPR_BITMAP)
+01434                 {
+01435                         for (int i=0; i<InfoList.GetSize(parent->m_128x128); i++)
+01436                         {
+01437                                 if (InfoList.Get(i, parent->m_128x128)->Selected)
+01438                                 {
+01439                                         switch (parent->m_128x128)
+01440                                         {
+01441                                         case 0:
+01442                                                 InfoList.clearTile128 (i, (CTile::TBitmap)(Texture-1));
+01443                                                 break;
+01444                                         case 1:
+01445                                                 InfoList.clearTile256 (i, (CTile::TBitmap)(Texture-1));
+01446                                                 break;
+01447                                         case 2:
+01448                                                 InfoList.clearTransition (i, (CTile::TBitmap)(Texture-1));
+01449                                                 break;
+01450                                         case 3:
+01451                                                 InfoList.clearDisplacement (i);
+01452                                                 break;
+01453                                         default:
+01454                                                 nlassert (0); // no!
+01455                                         }
+01456                                 }
+01457                         }
+01458                         bPopup = 0;
+01459                 }
+01460                 else if ((id==ID_MENU_ADD)||(id==ID_MENU_REPLACE))
+01461                 {
+01462                         _chdir (LastPath.c_str());
+01463                         CFileDialog load(true, NULL, LastPath.c_str(), OFN_ENABLESIZING | OFN_ALLOWMULTISELECT,
+01464                                 "Targa bitmap (*.tga)|*.tga|All files (*.*)|*.*||",NULL);
+01465                         load.m_ofn.lpstrFile = new char[10000]; //le buffer contient la list de tous les noms de fichier
+01466                         load.m_ofn.lpstrFile[0] = 0;
+01467                         //avec 10ko on devrait tranquille ... si l'ensemble des noms des fichiers depassent 10000 cara, l'insertion n'a pas lieu
+01468                         load.m_ofn.nMaxFile = 10000-1;
+01469                         if (load.DoModal()==IDOK)
+01470                         {
+01471                                 //AfxMessageBox ("toto");
+01472                                 POSITION p = load.GetStartPosition(); //la doc dit que p=NULL quand il n'y a pas de selection : c'est faux, genial les MFC
+01473                                 while (p)
+01474                                 {
+01475                                         CString str = load.GetNextPathName(p);
+01476 
+01477                                         char sDrive[256];
+01478                                         char sPath[256];
+01479                                         _splitpath (str, sDrive, sPath, NULL, NULL);
+01480                                         LastPath=string (sDrive)+string (sPath);
+01481 
+01482                                         if (str!=CString(""))
+01483                                         {
+01484                                                 int index=0;
+01485                                                 const char *pathname = (LPCTSTR)str;
+01486 
+01487                                                 // Add mode, to the end of the list
+01488                                                 if (id==ID_MENU_ADD)
+01489                                                 {
+01490                                                         // Index of the new tile
+01491                                                         int index;
+01492 
+01493                                                         // Index in the list
+01494                                                         switch (parent->m_128x128)
+01495                                                         {
+01496                                                         case 0:
+01497                                                                 // Add a 128 tile
+01498                                                                 index=InfoList.addTile128 ();
+01499 
+01500                                                                 // Set the tile
+01501                                                                 if (!InfoList.setTile128 (index, pathname, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha)))
+01502                                                                         // If prb, remove it
+01503                                                                         InfoList.removeTile128 (index);
+01504 
+01505                                                                 break;
+01506                                                         case 1:
+01507                                                                 // Add a 128 tile
+01508                                                                 index=InfoList.addTile256 ();
+01509 
+01510                                                                 // Set the tile
+01511                                                                 if (!InfoList.setTile256 (index, pathname, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha)))
+01512                                                                         // If prb, remove it
+01513                                                                         InfoList.removeTile256 (index);
+01514 
+01515                                                                 break;
+01516                                                         case 2:
+01517                                                                 nlassert (0);           // no, can't add transition
+01518                                                                 break;
+01519                                                         }
+01520                                                 }
+01521                                                 else
+01522                                                 {
+01523                                                         // Must be a replace mode.
+01524                                                         nlassert (id==ID_MENU_REPLACE);
+01525 
+01526                                                         // For each tile
+01527                                                         for (int index=0; index<InfoList.GetSize(parent->m_128x128); index++)
+01528                                                         {
+01529                                                                 // If selected
+01530                                                                 if (InfoList.Get(index, parent->m_128x128)->Selected)
+01531                                                                 {
+01532                                                                         switch (parent->m_128x128)
+01533                                                                         {
+01534                                                                         case 0:
+01535                                                                                 // Set the 128 tile
+01536                                                                                 InfoList.setTile128 (index, pathname, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha));
+01537                                                                                 break;
+01538                                                                         case 1:
+01539                                                                                 // Set the 256 tile
+01540                                                                                 InfoList.setTile256 (index, pathname, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha));
+01541                                                                                 break;
+01542                                                                         case 2:
+01543                                                                                 // Alpha texture ?
+01544                                                                                 if (Texture!=3)
+01545                                                                                 {
+01546                                                                                         InfoList.setTileTransition (index, pathname, Texture==1?CTile::diffuse:(Texture==2?CTile::additive:CTile::alpha));
+01547                                                                                 }
+01548                                                                                 // Alpha!
+01549                                                                                 else
+01550                                                                                 {
+01551                                                                                         // Select rotation
+01552                                                                                         SelectRotation selectRotation;
+01553                                                                                         if (selectRotation.DoModal()==IDOK)
+01554                                                                                         {
+01555                                                                                                 // Set the alpha tile with the good rotation
+01556                                                                                                 InfoList.setTileTransitionAlpha (index, pathname, selectRotation.RotSelected);
+01557                                                                                         }
+01558                                                                                 }
+01559                                                                                 break;
+01560                                                                         case 3:
+01561                                                                                 // Displacement
+01562                                                                                 InfoList.setDisplacement (index, pathname);
+01563                                                                                 break;
+01564                                                                         default:
+01565                                                                                 nlassert (0); // no!
+01566                                                                         }
+01567                                                                 }
+01568 
+01569                                                                 // Reload last inserted tile
+01570                                                                 InfoList.Reload(index, 1, parent->m_128x128);
+01571                                                                 InfoList.Get(index, parent->m_128x128)->Selected = 0;
+01572                                                         }
+01573                                                 }
+01574                                         }
+01575                                 }
+01576                         }
+01577                         delete load.m_ofn.lpstrFile;
+01578                         //InfoList.Sort();
+01579                         bPopup = 0;
+01580                 }
+01581                 else if (id==12)
+01582                 {
+01583                         ViewTileMode = 1;
+01584                         Browse *parent = (Browse*) this->GetParent();
+01585                         parent->SendMessage(WM_PAINT,0,0);
+01586                         bPopup = 0;
+01587                 }
+01588                 this->RedrawWindow();
+01589         }
+01590         return CStatic::WindowProc(message, wParam, lParam);
+01591 }
+01592         
+01593 
+01594 void CTView::OnRButtonDown(UINT nFlags, CPoint point) 
+01595 {       
+01596         // TODO: Add your message handler code here and/or call default
+01597         if (!lockInsertion)
+01598         {
+01599                 Browse *parent = (Browse*)this->GetParent();
+01600                 RECT wndpos; CMenu popup;
+01601                 GetParent()->GetWindowRect(&wndpos);
+01602                 popup.CreatePopupMenu();
+01603 
+01604                 int c = 0;
+01605                 for (tilelist::iterator p = InfoList.GetFirst(parent->m_128x128);p!=InfoList.GetLast(parent->m_128x128);++p)
+01606                 {
+01607                         if (p->Selected) c++;
+01608                 }               
+01609                                 
+01610                 if (!ViewTileMode)
+01611                 {
+01612                         popup.AppendMenu(parent->m_128x128<2 ? MF_STRING : MF_STRING | MF_GRAYED, ID_MENU_ADD,"Add...");
+01613                         popup.AppendMenu(c>0 ? MF_STRING : MF_STRING | MF_GRAYED, ID_MENU_REPLACE, "Replace...");
+01614                         popup.AppendMenu(c>0 ? MF_STRING : MF_STRING | MF_GRAYED, ID_MENU_SUPR_BITMAP, "Del bitmap");
+01615                         popup.AppendMenu((c>0 && parent->m_128x128<2) ? MF_STRING : MF_STRING | MF_GRAYED, ID_MENU_SUPR_TILE, "Del tile");
+01616                 }
+01617                 else
+01618                 {
+01619                 }
+01620                 bPopup = 1;
+01621                 popup.TrackPopupMenu(TPM_LEFTALIGN,MousePos.x+wndpos.left,MousePos.y+wndpos.top,GetParent(),NULL);
+01622         }
+01623         CStatic::OnRButtonDown(nFlags, point);
+01624 }
+01625 
+01626 void CTView::OnLButtonDown(UINT nFlags, CPoint point) 
+01627 {
+01628         // TODO: Add your message handler code here and/or call default
+01629         SendMessage(WM_PAINT,0,0);
+01630         CStatic::OnLButtonDown(nFlags, point);
+01631 }
+01632 
+01633 
+01634 void CTView::OnLButtonDblClk(UINT nFlags, CPoint point) 
+01635 {
+01636         // TODO: Add your message handler code here and/or call default
+01637 }
+01638 
+