void PaletteColor::UpdateBitmaps(){
Vector col = m_color.Convert(COLOR_SOURCE_DISPLAY).AsVector();
Float dim = 0.7;
updateBitmap(m_normalBitmap, col,m_w,m_h,1.f, 0.f, NULL, 0.0f);
updateBitmap(m_hoverBitmap, col*dim,m_w,m_h,0.5f,0.5f,m_refreshIcon, 1.0f);
updateBitmap(m_leftHoverBitmap, col*dim,m_w,m_h,0.f, 0.5f,m_leftArrowIcon, 1.0f);
updateBitmap(m_rightHoverBitmap,col*dim,m_w,m_h,1.f, 0.5f,m_rightArrowIcon,1.0f);
updateBitmap(m_crossHoverBitmap,col*dim,m_w,m_h,0.5f,0.5f,m_crossIcon ,1.0f);
}
void free_page(vAddr address) {
sem_wait(memory_lock); // Wait for the semaphore lock
// Look up for the page table entry
int ctr = 0; // Loop counter
for( ; ctr < TOTAL_SYSTEM_MEM_STORAGE; ctr++ ) {
if( pageTable[ctr].pageNumber == address ) {
// We found the page
// Tell the user
if(DEBUG) printf("Page #%d was freed from the paging simulator.\n", getPageTableNumber(pageTable[ctr].level, pageTable[ctr].index));
// Clean up now
if( pageTable[ctr].level == 0 )
ramStorage[pageTable[ctr].index] = 0;
else if( pageTable[ctr].level == 1 )
ssdStorage[pageTable[ctr].index] = 0;
else if( pageTable[ctr].level == 2 )
hddStorage[pageTable[ctr].index] = 0;
// Free this page's bitmap before clearing all its necessary data
updateBitmap( pageTable[ctr].level, pageTable[ctr].index, 1); // This memory location is now AVAILABLE
// Clear up the page table entry
pageTable[ctr].pageNumber = -1; // We don't have a page here no more
pageTable[ctr].level = -1; // We don't want to point anywhere
pageTable[ctr].index = -1; // We don't want to point anywhere
pageTable[ctr].memory = NULL; // No memory location will be stored here
pageTable[ctr].presentBit = 0; // This page is no longer present in the memory
// Decrement overallMemoryUsed
overallMemoryUsed--;
// Exit the loop
sem_post(memory_lock); // Release semaphore lock
return;
}
}
// We didn't find the desired page
sem_post(memory_lock); // Release semaphore lock
return; // We still gotta return
}
/*
* Deletes a file
*/
static int cs1550_unlink(const char *path)
{
char dir[MAX_FILENAME + 1];
char fileName[MAX_FILENAME + 1];
char ext[MAX_EXTENSION + 1];
getPath(path, dir, fileName, ext);
int pathType = getPathType(path, dir, fileName, ext);
int fileSize = getFileSize(dir, fileName, ext, pathType);
if (pathType < 2) {
return -EISDIR;
}
else if (fileSize == -1){
return -ENOENT;
}
else {
cs1550_directory_entry parentDir;
getDir(&parentDir, dir);
int i =0;
for (i = 0; i < parentDir.nFiles; i++) {
if ((pathType==2 && strcmp(parentDir.files[i].fname, fileName)==0) || (pathType==3 && strcmp(parentDir.files[i].fname, fileName) == 0 && strcmp(parentDir.files[i].fext, ext) == 0)) {
long startBlock = parentDir.files[i].nStartBlock;
long seek = startBlock;
FILE *f = fopen(".disk", "rb");
while(seek != 0) {
fseek(f, seek, SEEK_SET);
cs1550_disk_block curBlock;
fread(&curBlock, BLOCK_SIZE, 1, f);
cs1550_disk_block empty;
memset(&empty, 0, BLOCK_SIZE);
writeBlock(&empty, seek);
int index = seek / BLOCK_SIZE;
updateBitmap(index, 0);
if (curBlock.magic_number != 0) {
seek = curBlock.magic_number;
}
else {
seek = 0;
}
}
fclose(f);
int x =0;
for (x = 0; x < parentDir.nFiles; x++) {
if (x >= i && x != parentDir.nFiles-1) {
strcpy(parentDir.files[x].fname, parentDir.files[x+1].fname);
strcpy(parentDir.files[x].fext, parentDir.files[x+1].fext);
parentDir.files[x].fsize = parentDir.files[x+1].fsize;
parentDir.files[x].nStartBlock = parentDir.files[x+1].nStartBlock;
}
}
parentDir.nFiles--;
updateDir(&parentDir, dir);
}
}
}
return 0;
}
void BMPYUVImage::updateFromRawImage() {
if (YUVImage::rawImageDimensionsEnlarged()) {
bitmap = QImage(rawImage->get()->width(),
rawImage->get()->height(),
QImage::Format_RGB32);
}
YUVImage::updateFromRawImage();
updateBitmap();
}
/*
* Does the actual creation of a file. Mode and dev can be ignored.
*
*/
static int cs1550_mknod(const char *path, mode_t mode, dev_t dev)
{
(void) mode;
(void) dev;
char dir[MAX_FILENAME + 1];
char fileName[MAX_FILENAME + 1];
char ext[MAX_EXTENSION + 1];
getPath(path, dir, fileName, ext);
int pathType = getPathType(path, dir, fileName, ext);
int fileSize = getFileSize(dir, fileName, ext, pathType);
if (pathType < 2) {
return -EPERM;
}
else if (fileSize != -1){
return -EEXIST;
}
else if (strlen(fileName) > MAX_FILENAME || strlen(ext) > MAX_EXTENSION) {
return -ENAMETOOLONG;
}
else {
cs1550_root_directory r;
getRoot(&r);
int i =0;
for(i = 0; i < r.nDirectories; i++) {
if (strcmp(r.directories[i].dname, dir) == 0) {
int blockNum = getNextBlock();
long startBlock = (long)(BLOCK_SIZE * blockNum);
updateBitmap(blockNum, 1);
cs1550_directory_entry parentDir;
getDir(&parentDir, dir);
strcpy(parentDir.files[parentDir.nFiles].fname, fileName);
strcpy(parentDir.files[parentDir.nFiles].fext, ext);
parentDir.files[parentDir.nFiles].fsize = 0;
parentDir.files[parentDir.nFiles].nStartBlock = startBlock;
parentDir.nFiles++;
int parentDirMagicNum = r.directories[i].nStartBlock;
FILE *f = fopen(".disk", "rb+");
if (f != NULL) {
fseek(f, 0, SEEK_END);
int diskSize = ftell(f);
rewind(f);
char *buffer = (char *)malloc(diskSize);
fread(buffer, diskSize, 1, f);
rewind(f);
memmove(buffer+parentDirMagicNum, &parentDir, BLOCK_SIZE);
fwrite(buffer, diskSize, 1, f);
fclose(f);
free(buffer);
}
}
}
}
return 0;
}
//Creates a new empty directory on .disk
static void createDir(char *dir) {
int block_number = getNextBlock();
if (block_number != -1) {
cs1550_root_directory r;
getRoot(&r);
strcpy(r.directories[r.nDirectories].dname, dir);
r.directories[r.nDirectories].nStartBlock = (long)(BLOCK_SIZE * block_number);
r.nDirectories = r.nDirectories + 1;
updateRootOnDisk(&r);
updateBitmap(block_number, 1);
}
}
/**
* @brief Write data on an opened file
*
* Help from FUSE
*
* Write should return exactly the number of bytes requested except on error.
*
* @param path file path
* @param buf buffer where we have data to write
* @param size quantity of bytes to write
* @param offset offset over the writing
* @param fi FUSE structure linked to the opened file
* @return 0 on success and <0 on error
**/
static int my_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
char buffer[BLOCK_SIZE_BYTES]; // 1 bloque de caracteres.
int bytes2Write = size, totalWrite = 0;
NodeStruct *node = myFileSystem.nodes[fi->fh]; // fh==File handle. May be filled in by filesystem in open().
fprintf(stderr, "--->>>my_write: path %s, size %zu, offset %jd, fh %"PRIu64"\n", path, size, (intmax_t)offset, fi->fh);
// Increase the file size if it is needed
if(resizeNode(fi->fh, size + offset) < 0)
return -EIO;
// Write data
while(bytes2Write) {
int i;
int currentBlock, offBloque;
currentBlock = node->blocks[offset / BLOCK_SIZE_BYTES];
offBloque = offset % BLOCK_SIZE_BYTES;
// posicionas el cursor del archivo en el bloque + offset.
// lees un bloque entero empezando en esa posición. SI alguno de los dos falla exit.
if((lseek(myFileSystem.fdVirtualDisk, currentBlock * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(read(myFileSystem.fdVirtualDisk, &buffer, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/read in my_write");
return -EIO;
}
// Desde el punto inicial del offset, hasta el final del bloque, escribes la información
// del buf (texto que nos pasan en la función) en el buffer.
for(i = offBloque; (i < BLOCK_SIZE_BYTES) && (totalWrite < size); i++) {
buffer[i] = buf[totalWrite++];
}
// GUardas el buffer con la información modificada en el archivo indicado en el descriptor físico.
if((lseek(myFileSystem.fdVirtualDisk, currentBlock * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(write(myFileSystem.fdVirtualDisk, &buffer, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/write in my_write");
return -EIO;
}
// Discont the written stuff
bytes2Write -= (i - offBloque);
offset += i;
}
sync();
node->modificationTime = time(NULL);
updateSuperBlock(&myFileSystem);
updateBitmap(&myFileSystem);
updateNode(&myFileSystem, fi->fh, node);
return size;
}
//--------------------------------------------------------------
void IntelFaceScanner::threadedFunction(){
pxcStatus result;
while ((scanningFramesRemaining) && (isThreadRunning()))
{
pxcStatus status = senseManager->AcquireFrame(true);
if (checkDeviceConnection(senseManager->IsConnected()))
{
if (status < PXC_STATUS_NO_ERROR) {
ofLogError() << "Error with Sensemanager...! status=" << status;
return;
}
frameCounter++;
}
if (scanner->IsScanning())
{
if(!bDoScan) {
bDoScan = true;
//ofNotifyEvent(scanningStartedEvent,this);
ofLogNotice("IntelFaceScanner") << "Scanning started... frame:" << frameCounter;
}
scanningFramesRemaining--;
}
// Get the preview image for this frame
PXCImage* preview_image = scanner->AcquirePreviewImage();
senseManager->ReleaseFrame();
if(preview_image) {
updateBitmap(preview_image);
preview_image->Release();
}
}
ofLogNotice("IntelFaceScanner") << "Rendering scan... frame:" << frameCounter;
ofNotifyEvent(scanningStartedEvent,this);
renderScan();
ofLogNotice("IntelFaceScanner") << "Scanning stopped... frame:" << frameCounter;
curframeCounter = frameCounter;
ofNotifyEvent(scanningDoneEvent,this);
}
int my_unlink(const char *filename) {
// printDirectory(myFileSystem.directory); // DEBUG stuff only for debugging
/***** Copiar filename sin '/' en una nueva variable para
***** poder pasarla a findFileByNAme (que no admite strings constantes) ****/
int i=0;
char* fname=(char*)(filename+1); // Convert ffrom const char to char. Y también, quitar el primer character (/) sumando uno al puntero de filename (hace algoritimia de punteros.)
/** 1. Buscar si el archivo está en nuestro directorio **/
/** Si está, liberar el archivo y poner el nombre a empty **/
/** OJO! NO hay que tocar nodeIdx... **/
int nodeIndexDir = findFileByName(&myFileSystem, fname); // NodeIDx índice que ocupa un nodo en el array de nodos
if (nodeIndexDir == -1) {
fprintf(stderr, "File wasn't found on the directory entry\n");
return -1; // File is not on the directory.
}
// FILE to erase is on the directory. Free the directory entry.
myFileSystem.directory.numFiles -= 1; // Decrementar numero de archivos en el directorio.
myFileSystem.directory.files[nodeIndexDir].freeFile = true; // Put the node in directory as free.
updateDirectory(&myFileSystem);
int nodeIdx = myFileSystem.directory.files[nodeIndexDir].nodeIdx; // Hacer una copia de nodoIDx del directorio que nos sirve para acceder al array de nodos.
NodeStruct* inode=myFileSystem.nodes[nodeIdx];
/** 2. Borrar datos y liberar nodo usando el nodeIdx obtenido del directorio **/
myFileSystem.numFreeNodes += 1; // Increase the number of free nodes by 1 because e erased one.
for (i=0;i<inode->numBlocks;i++)
myFileSystem.bitMap[inode->blocks[i]] = 0; // Marcar bloques de datos en bitmap como libre
myFileSystem.superBlock.numOfFreeBlocks+=inode->numBlocks;
updateBitmap(&myFileSystem);
updateSuperBlock(&myFileSystem);
/**********************************************
* Se podría poner unicamente a NULL? Es peor?
**********************************************/
inode->numBlocks=0;
inode->fileSize=0;
inode->freeNode=true; // Delete the note from the node's array.
updateNode(&myFileSystem,nodeIdx,inode);
free(inode);
myFileSystem.nodes[nodeIdx]=NULL;
//printAllNodes(myFileSystem.nodes);
//printDirectory(myFileSystem.directory); // DEBUG stuff only for debugging
fprintf(stderr, "\n Congrats!!! %s file deleted \n", filename);
return 0;
}
/**
* @brief Modifies the data size originally reserved by an inode, reserving or removing space if needed.
*
* @param idxNode inode number
* @param newSize new size for the inode
* @return int
**/
int resizeNode(uint64_t idxNode, size_t newSize) {
NodeStruct *node = myFileSystem.nodes[idxNode];
char block[BLOCK_SIZE_BYTES];
int i, diff = newSize - node->fileSize;
if(!diff)
return 0;
memset(block, 0, sizeof(char)*BLOCK_SIZE_BYTES);
/// File size increases
if(diff > 0) {
/// Delete the extra conent of the last block if it exists and is not full
if(node->numBlocks && node->fileSize % BLOCK_SIZE_BYTES) {
int currentBlock = node->blocks[node->numBlocks - 1];
if((lseek(myFileSystem.fdVirtualDisk, currentBlock * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(read(myFileSystem.fdVirtualDisk, &block, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/read in resizeNode");
return -EIO;
}
int offBlock = node->fileSize % BLOCK_SIZE_BYTES;
int bytes2Write = (diff > (BLOCK_SIZE_BYTES - offBlock)) ? BLOCK_SIZE_BYTES - offBlock : diff;
for(i = 0; i < bytes2Write; i++) {
block[offBlock++] = 0;
}
if((lseek(myFileSystem.fdVirtualDisk, currentBlock * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(write(myFileSystem.fdVirtualDisk, &block, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/write in resizeNode");
return -EIO;
}
}
/// File size in blocks after the increment
int newBlocks = (newSize + BLOCK_SIZE_BYTES - 1) / BLOCK_SIZE_BYTES - node->numBlocks;
if(newBlocks) {
memset(block, 0, sizeof(char)*BLOCK_SIZE_BYTES);
// We check that there is enough space
if(newBlocks > myFileSystem.superBlock.numOfFreeBlocks)
return -ENOSPC;
myFileSystem.superBlock.numOfFreeBlocks -= newBlocks;
int currentBlock = node->numBlocks;
node->numBlocks += newBlocks;
for(i = 0; currentBlock != node->numBlocks; i++) {
if(myFileSystem.bitMap[i] == 0) {
myFileSystem.bitMap[i] = 1;
node->blocks[currentBlock] = i;
currentBlock++;
// Clean disk (necessary for truncate)
if((lseek(myFileSystem.fdVirtualDisk, i * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(write(myFileSystem.fdVirtualDisk, &block, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/write in resizeNode");
return -EIO;
}
}
}
}
node->fileSize += diff;
}
/// File decreases
else {
// File size in blocks after truncation
int numBlocks = (newSize + BLOCK_SIZE_BYTES - 1) / BLOCK_SIZE_BYTES;
myFileSystem.superBlock.numOfFreeBlocks += (node->numBlocks - numBlocks);
for(i = node->numBlocks; i > numBlocks; i--) {
int nBloque = node->blocks[i - 1];
myFileSystem.bitMap[nBloque] = 0;
// Clean disk (it is not really necessary)
if((lseek(myFileSystem.fdVirtualDisk, nBloque * BLOCK_SIZE_BYTES, SEEK_SET) == (off_t) - 1) ||
(write(myFileSystem.fdVirtualDisk, &block, BLOCK_SIZE_BYTES) == -1)) {
perror("Failed lseek/write in resizeNode");
return -EIO;
}
}
node->numBlocks = numBlocks;
node->fileSize += diff;
}
node->modificationTime = time(NULL);
sync();
/// Update all the information in the backup file
updateSuperBlock(&myFileSystem);
updateBitmap(&myFileSystem);
updateNode(&myFileSystem, idxNode, node);
return 0;
}
int myMkfs(MyFileSystem *myFileSystem, int diskSize, char *backupFileName) {
// We create the virtual disk:
myFileSystem->fdVirtualDisk = open(backupFileName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
// Some minimal checks:
assert(sizeof(SuperBlockStruct) <= BLOCK_SIZE_BYTES);
assert(sizeof(DirectoryStruct) <= BLOCK_SIZE_BYTES);
int numBlocks = diskSize / BLOCK_SIZE_BYTES;
int minNumBlocks = 3 + MAX_BLOCKS_WITH_NODES + 1;
// 3 --> por el superbloque, el raiz y el mapa de bits.
// 1 --> porque al menos tenemos un bloque para datos.
int maxNumBlocks = NUM_BITS;
if(numBlocks < minNumBlocks) {
return -1;
}
if(numBlocks >= maxNumBlocks) {
return -2;
}
/// BITMAP
// Initialization
int i;
for(i = 0; i < NUM_BITS; i++) {
myFileSystem->bitMap[i] = 0;
}
// First three blocks will be superblock, bitmap and directory
myFileSystem->bitMap[BITMAP_IDX] = 1;
myFileSystem->bitMap[SUPERBLOCK_IDX] = 1;
myFileSystem->bitMap[DIRECTORY_IDX] = 1;
// Next MAX_BLOCKS_WITH_NODES will contain inodes
for(i = 3; i < 3 + MAX_BLOCKS_WITH_NODES; i++) {
myFileSystem->bitMap[i] = 1;
}
updateBitmap(myFileSystem);
/// DIRECTORY
// Initialization
myFileSystem->directory.numFiles = 0;
for(i = 0; i < MAX_FILES_PER_DIRECTORY; i++) {
myFileSystem->directory.files[i].freeFile = 1;
}
updateDirectory(myFileSystem);
/// INODES
NodeStruct currentNode;
currentNode.freeNode = 1;
for(i = 0; i < MAX_NODES; i++) {
updateNode(myFileSystem, i, ¤tNode);
}
/// SUPERBLOCK
initializeSuperBlock(myFileSystem, diskSize);
updateSuperBlock(myFileSystem);
sync();
// At the end we have at least one block
assert(myQuota(myFileSystem) >= 1);
if(initializeNodes(myFileSystem)){
myFree(myFileSystem);
return -3;
}
printf("SF: %s, %d B (%d B/block), %d blocks\n", backupFileName, diskSize, BLOCK_SIZE_BYTES, numBlocks);
printf("1 block for SUPERBLOCK (%u B)\n", (unsigned int)sizeof(SuperBlockStruct));
printf("1 block for BITMAP, covering %u blocks, %u B\n", (unsigned int)NUM_BITS, (unsigned int)(NUM_BITS * BLOCK_SIZE_BYTES));
printf("1 block for DIRECTORY (%u B)\n", (unsigned int)sizeof(DirectoryStruct));
printf("%d blocks for inodes (%u B/inode, %u inodes)\n", MAX_BLOCKS_WITH_NODES, (unsigned int)sizeof(NodeStruct), (unsigned int)MAX_NODES);
printf("%d blocks for data (%d B)\n", myFileSystem->superBlock.numOfFreeBlocks, BLOCK_SIZE_BYTES * myFileSystem->superBlock.numOfFreeBlocks);
printf("Formatting completed!\n");
return 0;
}
void BMPYUVImage::updateFromRoboImage() {
YUVImage::updateFromRoboImage();
updateBitmap();
}
int *addNewPage(int pageNumber) {
int *toReturn = (int*)malloc(sizeof(int) * 2);
// Set some default values
toReturn[0] = -1; // We couldn't add the page as requested on any level
toReturn[1] = -1; // The page cannot be accessed at the given level of storage
// See if we've got space in the RAM
if( RAMMemoryUsed < RAM_STORAGE_COUNT ) {
// We've got storage in the RAM
toReturn[0] = 0; // Level is RAM
toReturn[1] = findEmptySlotAt(0)[1]; // Index into the first free empty slot got in the RAM
// Increase memory usage by updating the RAM bitmap
updateBitmap(0, toReturn[1], 0); // The RAM location is NO longer free
// Tell the user
if(DEBUG) printf("A new page with page #%d was directly created in the RAM.\n", pageNumber);
// Return the requested item
return toReturn;
} else if( SSDMemoryUsed < SSD_STORAGE_COUNT ) {
// We've got no storage in the RAM
// STEP 1: Find the page to be evicted at RAM level
int pageIndexToEvictAtRAM = pickAPageToEvict(0)[1];
// STEP 2: Find a suitable index at level 1 to move it to
int *levelToMoveTo = findEmptySlotAt(1);
// STEP 3: Create levels to execute the swap
toReturn[0] = 0; // To be evicted from RAM
toReturn[1] = pageIndexToEvictAtRAM; // Evict index
// STEP 4: Execute the swap
switchToMemoryLocation(toReturn, levelToMoveTo);
// STEP 5: Increase memory usage by updating the RAM and SSD bitmaps
updateBitmap(0, pageIndexToEvictAtRAM, 0); // The RAM location is NO longer free
updateBitmap(1, levelToMoveTo[1], 0); // The SSD location is NO longer free
// STEP 6: Tell the user
if(DEBUG) printf("A new page with page #%d was added to the RAM causing eviction of a page to the SSD with Page #%d\n", pageNumber, getPageTableNumber(1, levelToMoveTo[1]));
// STEP 7: Return the level which was freed up
return toReturn;
} else if( HDDMemoryUsed < HDD_STORAGE_COUNT ) {
// We've got no storage in RAM
// STEP 1: Find the page to be evicted at the SSD level
int *pageEvictedFromSSD = pickAPageToEvict(1);
// STEP 2: Find slot in the HDD level to place the SSD page
int *destinationInHDD = findEmptySlotAt(2);
// STEP 3: Perform the swap
switchToMemoryLocation(pageEvictedFromSSD, destinationInHDD);
// STEP 4: Find the RAM page to be moved out now
int *pageEvictedFromRAM = pickAPageToEvict(0);
// STEP 5: Resolve the location to place this RAM page
int *destinationInSSD = pageEvictedFromSSD;
// STEP 6: Perform the swap
switchToMemoryLocation(pageEvictedFromRAM, destinationInSSD);
// STEP 7: Resolve the empty spot
toReturn[0] = 0; // Space freed up in RAM
toReturn[1] = pageEvictedFromRAM[1]; // Index of free location in the RAM
// STEP 8: Update the bitmaps
updateBitmap(0, pageEvictedFromRAM[1], 0); // This RAM location is NO longer free
updateBitmap(1, destinationInSSD[1], 0); // This SSD location is NO longer free
updateBitmap(2, destinationInHDD[1], 0); // This location in HDD is NO longer free as well
// STEP 9: Tell the user
if(DEBUG) printf("A new page with page #%d was added to the RAM causing eviction of a page from the RAM to the SSD with Page #%d and a page from SSD to the HDD with page #%d\n", pageNumber, getPageTableNumber(1, destinationInSSD[1]), getPageTableNumber(2, destinationInHDD[1]));
// STEP 10: Return the level which was freed up
return toReturn;
}
// If nothing matches, return the default values
return toReturn;
}
void gfxPreviewWind::Refresh()
{
CRect wsize;
GetWindowRect(wsize);
Point2I zero(0,0);
Point2I stretch(wsize.Width() - 1,wsize.Height() - 1);
pSurface->lock();
if (m_matType == TS::Material::MatNull) pSurface->clear(0);
else if (m_matType == TS::Material::MatPalette) pSurface->clear(m_pMaterial->fParams.fIndex);
else if (m_matType == TS::Material::MatTexture) {
if (updateBitmap() == false) return;
/* BOOL found=false;
CString tempPath = pSearchPath;
CString onePath;*/
CString theFile = m_pMaterial->fParams.fMapFile;
/* CString oneFullPath;
int foundindex;
while (!found && !tempPath.IsEmpty()) {
foundindex = tempPath.ReverseFind(';') + 1;
onePath= tempPath.Mid(foundindex);
tempPath= tempPath.Left(foundindex);
//look for file here
oneFullPath+= onePath+theFile;
if (GetFileAttributes(oneFullPath) != -1) found= 1;
}
if (!found) {
} else {*/
ResourceObject *obj= rm.load(theFile);
if (obj && obj->resource) {
m_pMaterial->load(rm, 1);
const GFXBitmap *pBitmap= m_pMaterial->getTextureMap();
AssertFatal(pBitmap, "gfxPreviewWind::Refresh: get Material TextureMap failed!");
pSurface->clear(0);
if (WantStretched) {
pSurface->drawBitmap2d(pBitmap, &Point2I(0,0), &Point2I(stretch.x, stretch.y));
} else {
pSurface->drawBitmap2d(pBitmap, &Point2I(0,0));
}
} else
pSurface->clear(0);
}
pSurface->unlock();
pSurface->update();
}
/*
* Write size bytes from buf into file starting from offset
*
*/
static int cs1550_write(const char *path, const char *buf, size_t size,
off_t offset, struct fuse_file_info *fi)
{
int ret = 0;
(void) fi;
char dir[MAX_FILENAME + 1];
char fileName[MAX_FILENAME + 1];
char ext[MAX_EXTENSION + 1];
getPath(path, dir, fileName, ext);
int pathType = getPathType(path, dir, fileName, ext);
int fileSize = getFileSize(dir, fileName, ext, pathType);
if (dirExists(dir) == 1 && pathType >= 2 && fileSize != -1 && size > 0) {
cs1550_directory_entry parentDir;
getDir(&parentDir, dir);
int i =0;
for (i = 0; i < parentDir.nFiles; i++) {
if ((pathType==2 && strcmp(parentDir.files[i].fname, fileName)==0) || (pathType==3 && strcmp(parentDir.files[i].fname, fileName) == 0 && strcmp(parentDir.files[i].fext, ext) == 0)) {
if (offset > parentDir.files[i].fsize) {
return -EFBIG;
}
else {
long startBlock = parentDir.files[i].nStartBlock;
int blockNum = offset / BLOCK_SIZE;
long seek = startBlock;
long bStart = 0;
FILE *f = fopen(".disk", "rb+");
int j = 0;
for (j = 0; j <= blockNum; j++) {
bStart = seek;
fseek(f, seek, SEEK_SET);
cs1550_disk_block fileBlock;
fread(&fileBlock, BLOCK_SIZE, 1, f);
seek = fileBlock.magic_number;
}
rewind(f);
int off = (int)offset - (blockNum * BLOCK_SIZE);
int index;
int count = off;
seek = bStart;
fseek(f, seek, SEEK_SET);
cs1550_disk_block curBlock;
fread(&curBlock, BLOCK_SIZE, 1, f);
for (index = 0; index < strlen(buf); index++) {
if (count < MAX_DATA_IN_BLOCK) {
curBlock.data[count] = (char)buf[index];
count++;
}
else {
count = 0;
if (curBlock.magic_number != 0) {
writeBlock(&curBlock, seek);
seek = curBlock.magic_number;
fseek(f, seek, SEEK_SET);
fread(&curBlock, BLOCK_SIZE, 1, f);
}
else {
long cSeek = seek;
int nextBlock = getNextBlock();
seek = nextBlock * BLOCK_SIZE;
curBlock.magic_number = seek;
writeBlock(&curBlock, cSeek);
fseek(f, seek, SEEK_SET);
fread(&curBlock, BLOCK_SIZE, 1, f);
updateBitmap(nextBlock, 1);
}
}
if (index == strlen(buf)-1) {
writeBlock(&curBlock, seek);
count = 0;
}
}
fclose(f);
int old = parentDir.files[i].fsize;
int newSize = (size - (old - offset)) + (old - (old - offset));
parentDir.files[i].fsize = newSize;
updateDir(&parentDir, dir);
ret = newSize;
}
}
}
}
return ret;
}
