Exemplo n.º 1
0
void Color::LoadICCProfiles()
{
	if(m_iccSearchPaths!= NULL){
		delete m_iccSearchPaths;
	}
    
    const Int32 NUMSEARCHPATHS = 4;
    
	m_iccSearchPaths = new String[NUMSEARCHPATHS];
	

	Filename cmykDir = GeGetPluginPath();
	cmykDir += Filename(String("cmyk"));

	m_iccSearchPaths[0] = cmykDir.GetString();
    m_iccSearchPaths[1] = "/Library/ColorSync/Profiles/";
    m_iccSearchPaths[2] = "/Users/vidarn/Library/ColorSync";
	m_iccSearchPaths[3] = "C:\\Windows\\System32\\Spool\\Drivers\\Color\\";

	Logger::AddLine("Creating LAB profile",1);
	m_LABProfile = cmsCreateLab4Profile(NULL);

	Logger::AddLine("Creating default sRGB profile",1);
	m_displayProfile = cmsCreate_sRGBProfile();
	m_RGBProfiles.Insert(vnColorProfile("sRGB",m_displayProfile),0);

    for(Int32 i=0;i<NUMSEARCHPATHS;++i){
        BrowseFiles* bf = BrowseFiles::Alloc();
        Filename dir(m_iccSearchPaths[i]);
        bf->Init(dir,FALSE);
        int RGBPos  = m_RGBProfiles.GetCount();
        int CMYKPos = m_CMYKProfiles.GetCount();
        int spotPos = m_spotProfiles.GetCount();

        if (bf)
        {
            while (bf->GetNext())
            {
                Filename fileName = bf->GetFilename();
                fileName.SetDirectory(dir);
                String str = fileName.GetString();
                Char *buffer = new Char[str.GetCStringLen()+1];
                str.GetCString(buffer,str.GetCStringLen()+1);
				Logger::AddLine(buffer,1);
                cmsHPROFILE profile = cmsOpenProfileFromFile(buffer, "r");
                if(profile != NULL){
                    cmsColorSpaceSignature sig = cmsGetColorSpace(profile);
                    Int32 length = cmsGetProfileInfoASCII(profile,cmsInfoDescription,"en","US",NULL,0);
                    Char *buffer2 = new Char[length];
                    cmsGetProfileInfoASCII(profile,cmsInfoDescription,"en","US",buffer2,length);
                    String info(buffer2);
                    int pt = _cmsLCMScolorSpace(sig);
                    if(PT_RGB == pt){
						Logger::AddLine("RGB profile",1);
                        m_RGBProfiles.Insert(vnColorProfile(info,profile),RGBPos);
                        RGBPos++;
                    }
                    if(PT_CMYK == pt){
                        cmsHTRANSFORM xform = cmsCreateTransform(profile,TYPE_NAMED_COLOR_INDEX,m_displayProfile,TYPE_RGB_DBL,INTENT_PERCEPTUAL,0);
                        if(xform != NULL){
                            cmsNAMEDCOLORLIST* colorList = cmsGetNamedColorList(xform);
                            if(colorList != NULL){
                                m_spotProfiles.Insert(vnColorProfile(info,profile),spotPos);
                                spotPos++;
                            }
                            else{
								Logger::AddLine("CMYK profile",1);
                                m_CMYKProfiles.Insert(vnColorProfile(info,profile),CMYKPos);
                                CMYKPos++;
                            }
							cmsDeleteTransform(xform);
                        }
                    }
                    delete buffer2;
                } else {
					Logger::AddLine("Invalid",1);
				}
                delete buffer;
            }
        }
        BrowseFiles::Free(bf);
    }
}
Exemplo n.º 2
0
void PlanPrep::Program_Control (void)
{
    int i, dump;
	char *str_ptr;

	Sort_Type input_sort;

	//---- open network files ----

	Demand_Service::Program_Control ();

	//---- open the input plans ----

	if (Get_Control_String (NODE_LIST_PATHS) != NULL) {
		type_flag = Get_Control_Flag (NODE_LIST_PATHS);
	}
	str_ptr = Get_Control_String (INPUT_PLAN_FILE);

	if (str_ptr == NULL) goto control_error;

	input_plans.File_Type ("Input Plan File");	

	str_ptr = Project_Filename (str_ptr, Extension ());

	Print_Filename (2, input_plans.File_Type (), str_ptr);

	input_plans.Filename (str_ptr);

	str_ptr = Get_Control_String (INPUT_PLAN_FORMAT);

	if (str_ptr != NULL) {
		input_plans.File_Format (str_ptr);
		Print (1, "%s Format = %s", input_plans.File_Type (), str_ptr);
	}
	input_plans.Node_Based_Flag (type_flag);

	if (!input_plans.Open (0)) {
		File_Error ("Opening Input Plan File", input_plans.Filename ());
	}
	type_flag = input_plans.Node_Based_Flag ();
	parts_flag = (input_plans.Extend () > 0);

	//---- input plan sort ----

	str_ptr = Get_Control_String (INPUT_PLAN_SORT);

	if (str_ptr != NULL) {
		Print (1, "Input Plan Sort = %s", str_ptr);

		if (str_cmp (str_ptr, "TRAVELER") == 0) {
			input_sort = TRAVELER_SORT;
		} else if (str_cmp (str_ptr, "TIME") == 0) {
			input_sort = TIME_SORT;
		} else {
			Error ("Unrecognized Input Plan Sort = %s", str_ptr);
		}
		input_plans.Plan_Sort (input_sort);
		input_sort_flag = true;
	} else {
		input_sort = input_plans.Plan_Sort ();
	}

	//---- open the merge plans ----

	str_ptr = Get_Control_String (MERGE_PLAN_FILE);

	if (str_ptr != NULL) {
		merge_plans.File_Type ("Merge Plan File");

		str_ptr = Project_Filename (str_ptr, Extension ());

		Print_Filename (2, merge_plans.File_Type (), str_ptr);

		merge_plans.Filename (str_ptr);
		merge_plans.Extend (input_plans.Extend ());

		str_ptr = Get_Control_String (MERGE_PLAN_FORMAT);

		if (str_ptr != NULL) {
			merge_plans.File_Format (str_ptr);
			Print (1, "%s Format = %s", merge_plans.File_Type (), str_ptr);
		}
		merge_plans.Node_Based_Flag (type_flag);

		if (!merge_plans.Open (0)) {
			File_Error ("Opening Merge Plan File", merge_plans.Filename ());
		}
		merge_flag = true;
		if (merge_plans.Node_Based_Flag () != type_flag) {
			Error ("Incompatible Plan Formats");
		}
	}

	//---- open the subarea plans ----

	str_ptr = Get_Control_String (SUBAREA_PLAN_FILE);

	if (str_ptr != NULL) {
		if (merge_flag) {
			Error ("Merge and Subarea Plans are Incompatible");
		}
		subarea_plans.File_Type ("Subarea Plan File");

		str_ptr = Project_Filename (str_ptr);

		subarea_plans.Filename (str_ptr);

		if (subarea_plans.Extend () > 0) {
			if (parts_flag) {
				subpart_flag = true;
			} else {
				str_ptr = subarea_plans.Pathname ();
				str_ptr = Project_Filename (str_ptr, Extension ());
				subarea_plans.Filename (str_ptr);
				subarea_plans.Extend (0);
			}
		}
		Print_Filename (2, subarea_plans.File_Type (), str_ptr);

		str_ptr = Get_Control_String (SUBAREA_PLAN_FORMAT);

		if (str_ptr != NULL) {
			subarea_plans.File_Format (str_ptr);
			Print (1, "%s Format = %s", subarea_plans.File_Type (), str_ptr);
		}
		subarea_plans.Node_Based_Flag (type_flag);

		if (!subarea_plans.Open (0)) {
			File_Error ("Opening Subarea Plan File", subarea_plans.Filename ());
		}
		subarea_flag = true;
		if (subarea_plans.Node_Based_Flag () != type_flag) {
			Error ("Incompatible Plan Formats");
		}
	}

	//---- open the output plans ----

	str_ptr = Get_Control_String (OUTPUT_PLAN_FILE);

	if (str_ptr != NULL) {
		output_plans.File_Type ("Output Plan File");

		str_ptr = Project_Filename (str_ptr, Extension ());

		Print_Filename (2, output_plans.File_Type (), str_ptr);

		output_plans.Filename (str_ptr);
		output_plans.File_Access (CREATE);

		str_cpy (output_name, sizeof (output_name), output_plans.Pathname ());
		extend = output_plans.Extend ();
		output_flag = true;

		str_ptr = Get_Control_String (OUTPUT_PLAN_FORMAT);

		if (str_ptr != NULL) {
			output_plans.File_Format (str_ptr);
			Print (1, "%s Format = %s", output_plans.File_Type (), str_ptr);

			binary_flag = (output_plans.File_Format () == BINARY);
		}
		output_plans.Node_Based_Flag (type_flag);

	} else if (merge_flag) {
		Error ("Plan Merging Requires an Output File");
	} else if (subarea_flag) {
		Error ("Subarea Merging Requires an Output File");
	}

	//---- plan sort option ----

	str_ptr = Get_Control_String (PLAN_SORT_OPTION);

	if (str_ptr != NULL && output_flag) {
		Print (2, "Plan Sort Option = %s", str_ptr);

		if (str_cmp (str_ptr, "TRAVELER") == 0) {
			sort = TRAVELER_SORT;
		} else if (str_cmp (str_ptr, "TIME") == 0) {
			if (merge_flag) {
				Error ("Plan Merging must be performed in TRAVELER Sort");
			}
			sort = TIME_SORT;
		} else {
			Error ("Unrecognized Plan Sort Option = %s", str_ptr);
		}
		if (!input_sort_flag || input_sort != sort) {
			input_plans.Plan_Memory (ALLOCATE_MEMORY);
			input_plans.Plan_Sort (sort);
			sort_flag = true;
		}
		if (sort_flag && subarea_flag) {
			Error ("Sorting and Subarea Merging are Incompatible");
		}
	}

	//---- plan combine option ----

	str_ptr = Get_Control_String (PLAN_COMBINE_OPTION);

	if (str_ptr != NULL && parts_flag && output_flag) {
		Print (2, "Plan Combine Option = %s", str_ptr);

		if (!input_sort_flag && !sort_flag) {
			Error ("The Input Sort or Sort Option are needed for Plan Combining");
		}
		if (str_cmp (str_ptr, "FILE") == 0) {
			combine = FILE_COMBINE;
		} else if (str_cmp (str_ptr, "MEMORY") == 0) {
			if (merge_flag) {
				Error ("Plan Merging and Memory Combining are Incompatible");
			} else if (subarea_flag) {
				Error ("Subarea Merging and Memory Combining are Incompatible");
			}
			if (sort_flag) {
				combine = MEMORY_COMBINE;
			} else {
				combine = FILE_COMBINE;
			}
		} else {
			Error ("Unrecognized Plan Combine Option = %s", str_ptr);
		}
		combine_flag = true;
	}

	//---- max plan size ----

	str_ptr = Get_Control_String (MAX_OUTPUT_PLAN_SIZE);

	if (str_ptr != NULL && (combine_flag || (!parts_flag && output_flag))) {
		Print (2, "Maximum Output Plan Size = %s megabytes", str_ptr);

		max_size = atol (str_ptr);

		if (max_size < 1 || max_size > 2048) {
			Error ("Maximum Output Plan Size %d is Out of Range (1-2048)", max_size);
		}
		max_size *= 1024 * 1024;
		max_size_flag = true;
	}

	//---- get the select traveler range ----
	
	str_ptr = Get_Control_String (SELECT_TRAVELER_RANGE);

	if (str_ptr != NULL) {
		Print (2, "Select Traveler Range = %s", str_ptr);

		if (!hhold_range.Add_Ranges (str_ptr)) {
			Error ("Select Traveler Range", str_ptr);
		}
		hhold_flag = true;
	}

	//---- get the select time periods ----
	
	str_ptr = Get_Control_String (SELECT_TIME_PERIODS);

	if (str_ptr != NULL) {
		Print (2, "Select Time Periods = %s", str_ptr);

		time_period.Format (Time_Step::HOURS);

		if (!time_period.Add_Ranges (str_ptr)) {
			File_Error ("Time Period Range", str_ptr);
		}
		time_flag = true;
	}

	//---- read the selection percentage ----

	str_ptr = Get_Control_String (SELECTION_PERCENTAGE);

	if (str_ptr != NULL) {
		if (input_sort != TRAVELER_SORT) {
			Error ("The Input Plans must be in Traveler order for Plan Selection");
		}
		Get_Double (str_ptr, &percent);

		if (percent < 0.1 || percent > 100.0) {
			Error ("Selection Percentage %.2lf is Out of Range (0.1-100.0)", percent);
		}
		Print (2, "Selection Percentage = %.2lf", percent);

		percent /= 100.0;
		select_flag = (percent != 1.0);
	}

	if ((time_flag || select_flag || hhold_flag) && subarea_flag) {
		Error ("Subarea Merging and Plan Selections are Incompatible");
	}

	//---- check plan partitions ----

	str_ptr = Get_Control_String (CHECK_PLAN_PARTITIONS);

	if (str_ptr != NULL) {
		check_flag = Get_Control_Flag (CHECK_PLAN_PARTITIONS);

		Print (2, "Check Plan Partitions = %s", str_ptr);

		if (check_flag) {
			partition.Initialize (sizeof (Partition));
		}
	}

	//---- update plan partitions ----

	str_ptr = Get_Control_String (UPDATE_PLAN_PARTITIONS);

	if (str_ptr != NULL) {
		partition_flag = Get_Control_Flag (UPDATE_PLAN_PARTITIONS);

		Print (2, "Update Plan Partitions = %s", str_ptr);
	}

	//---- get the household list file ----

	str_ptr = Get_Control_String (HOUSEHOLD_LIST);

	if (str_ptr != NULL) {
		hhlist_file.File_Type ("Household List");
		hhlist_file.Filename (Project_Filename (str_ptr));

		Print_Filename (2, hhlist_file.File_Type (), str_ptr);

		if (!hhlist_file.Open (0)) {
			File_Error ("Opening Household List File", hhlist_file.Filename ());
		}
		hhlist_flag = true;
	} else if (partition_flag) {
		Error ("Household Lists are required for Partition Updates");
	}

	if (hhlist_flag) {
		combine_flag = false;

		if (sort_flag) {
			Error ("Plan Sorting and Household Lists are Incompatible");
		}
		if (merge_flag) {
			Error ("Plan Merging and Household Lists are Incompatible");
		} else if (subarea_flag) {
			Error ("Subarea Merging and Household Lists are Incompatible");
		}
		if (check_flag) {
			Error ("Checking and Updating Plan Partitions are Incompatible");
		}
		if (!output_flag) {
			Error ("Output Plans are Required for Household Lists");
		}
		partition.Initialize (sizeof (Partition));
	}

	//---- get the delete household list file ----

	str_ptr = Get_Control_String (DELETE_HOUSEHOLD_LIST);

	if (str_ptr != NULL) {
		delete_file.File_Type ("Delete Household List");
		delete_file.Filename (Project_Filename (str_ptr));

		Print_Filename (2, delete_file.File_Type (), str_ptr);

		if (!delete_file.Open (0)) {
			File_Error ("Opening Delete Household List File", delete_file.Filename ());
		}
		delete_flag = true;
	}

	//---- get the delete one leg plans flag ----

	str_ptr = Get_Control_String (DELETE_ONE_LEG_PLANS);

	if (str_ptr != NULL) {
		one_leg_flag = Get_Control_Flag (DELETE_ONE_LEG_PLANS);

		Print (1, "Delete One Leg Plans = %s", str_ptr);
	}

	//---- get the fix plan file ----

	str_ptr = Get_Control_String (FIX_PLAN_FILE);

	if (str_ptr != NULL) {
		fix_file.File_Type ("Fix Plan File");

		if (!fix_file.Open (Project_Filename (str_ptr))) {
			File_Error ("Opening Fix Plan File", fix_file.Filename ());
		}
		fix_flag = true;
	}

	//---- merge by trip ----

	str_ptr = Get_Control_String (MERGE_BY_TRIP);

	if (str_ptr != NULL) {
		trip_flag = Get_Control_Flag (MERGE_BY_TRIP);

		Print (2, "Merge by Trip = %s", str_ptr);
	}

	//---- random number seed ----

	if (select_flag || fix_flag) {
		str_ptr = Get_Control_String (RANDOM_NUMBER_SEED);

		if (str_ptr != NULL) {
			random.Seed (atoi (str_ptr));
		}
		Print (2, "Random Number Seed = %d", random.Seed ());
	}

	//---- check output file name ----

	if (output_flag) {
		output_plans.Plan_Sort (input_plans.Plan_Sort ());

		if (max_size_flag || !combine_flag) {
			extend = output_plans.Extend (input_plans.Extend ());
			if (extend == 0 && max_size_flag) {
				extend = output_plans.Extend (1);
			}
		}
		if (!hhlist_flag || !delete_flag) {
			if (!output_plans.Open (0)) {
				File_Error ("Creating Output Plan File", output_plans.Filename ());
			}
		}
		if (combine_flag && combine == FILE_COMBINE && (sort_flag || merge_flag || subarea_flag)) {

			//---- set the temporary output filename ----

			output_plans.Filename (Filename (output_name, TEMP_LABEL));
			output_plans.Extend (input_plans.Extend ());
			output_plans.File_Format (BINARY);
		}
	}
	
	//---- read report types ----

	compare_flag = path_flag = false;
	dump_path = dump_time = MAX_INTEGER;

	for (i=First_Report (); i != 0; i=Next_Report ()) {
		if (i != FIX_PLAN) compare_flag = true;

		if (i == PATH_CHANGE || i == DUMP_PATH_CHANGES) {
			path_flag = true;
			if (i == DUMP_PATH_CHANGES) {
				dump = (int) (Report_Data () * NUM_CHANGE_BINS / 100.0 + 0.5);
				if (dump < dump_path) {
					dump_path = dump;
				}
			}
		} else if (i == DUMP_TIME_CHANGES) {
			dump = (int) (Report_Data () * NUM_CHANGE_BINS / 100.0 + 0.5);
			if (dump < dump_time) {
				dump_time = dump;
			}
		}
	}

	if (compare_flag) {
		if (!merge_flag) {
			Write (1);
			Warning ("Change Reports require a Merge Plan File");
			compare_flag = false;
		}
		memset (time_changes, '\0', sizeof (time_changes));
		memset (path_changes, '\0', sizeof (path_changes));

		increment = MIDNIGHT / TOTAL_TIME_PERIOD;
	}
	return;

	//---- error message ----

control_error:
	Error ("Missing Control Key = %s", Current_Key ());
} 
Exemplo n.º 3
0
s32 CWII_IPC_HLE_Device_fs::ExecuteCommand(u32 _Parameter, u32 _BufferIn, u32 _BufferInSize, u32 _BufferOut, u32 _BufferOutSize)
{
	switch (_Parameter)
	{
	case IOCTL_GET_STATS:
		{
			if (_BufferOutSize < 0x1c)
				return -1017;

			WARN_LOG(WII_IPC_FILEIO, "FS: GET STATS - returning static values for now");

			NANDStat fs;

			//TODO: scrape the real amounts from somewhere...
			fs.BlockSize      = 0x4000;
			fs.FreeUserBlocks = 0x5DEC;
			fs.UsedUserBlocks = 0x1DD4;
			fs.FreeSysBlocks  = 0x10;
			fs.UsedSysBlocks  = 0x02F0;
			fs.Free_INodes    = 0x146B;
			fs.Used_Inodes    = 0x0394;

			*(NANDStat*)Memory::GetPointer(_BufferOut) = fs;

			return FS_RESULT_OK;
		}
		break;

	case IOCTL_CREATE_DIR:
		{
			_dbg_assert_(WII_IPC_FILEIO, _BufferOutSize == 0);
			u32 Addr = _BufferIn;

			u32 OwnerID = Memory::Read_U32(Addr); Addr += 4;
			u16 GroupID = Memory::Read_U16(Addr); Addr += 2;
			std::string DirName(HLE_IPC_BuildFilename((const char*)Memory::GetPointer(Addr), 64)); Addr += 64;
			Addr += 9; // owner attribs, permission
			u8 Attribs = Memory::Read_U8(Addr);

			INFO_LOG(WII_IPC_FILEIO, "FS: CREATE_DIR %s, OwnerID %#x, GroupID %#x, Attributes %#x", DirName.c_str(), OwnerID, GroupID, Attribs);

			DirName += DIR_SEP;
			File::CreateFullPath(DirName);
			_dbg_assert_msg_(WII_IPC_FILEIO, File::IsDirectory(DirName), "FS: CREATE_DIR %s failed", DirName.c_str());

			return FS_RESULT_OK;
		}
		break;

	case IOCTL_SET_ATTR:
		{
			u32 Addr = _BufferIn;

			u32 OwnerID = Memory::Read_U32(Addr); Addr += 4;
			u16 GroupID = Memory::Read_U16(Addr); Addr += 2;
			std::string Filename = HLE_IPC_BuildFilename((const char*)Memory::GetPointer(_BufferIn), 64); Addr += 64;
			u8 OwnerPerm = Memory::Read_U8(Addr); Addr += 1;
			u8 GroupPerm = Memory::Read_U8(Addr); Addr += 1;
			u8 OtherPerm = Memory::Read_U8(Addr); Addr += 1;
			u8 Attributes = Memory::Read_U8(Addr); Addr += 1;

			INFO_LOG(WII_IPC_FILEIO, "FS: SetAttrib %s", Filename.c_str());
			DEBUG_LOG(WII_IPC_FILEIO, "    OwnerID: 0x%08x", OwnerID);
			DEBUG_LOG(WII_IPC_FILEIO, "    GroupID: 0x%04x", GroupID);
			DEBUG_LOG(WII_IPC_FILEIO, "    OwnerPerm: 0x%02x", OwnerPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    GroupPerm: 0x%02x", GroupPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    OtherPerm: 0x%02x", OtherPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    Attributes: 0x%02x", Attributes);

			return FS_RESULT_OK;
		}
		break;

	case IOCTL_GET_ATTR:
		{
			_dbg_assert_msg_(WII_IPC_FILEIO, _BufferOutSize == 76,
				"    GET_ATTR needs an 76 bytes large output buffer but it is %i bytes large",
				_BufferOutSize);

			u32 OwnerID = 0;
			u16 GroupID = 0x3031; // this is also known as makercd, 01 (0x3031) for nintendo and 08 (0x3038) for MH3 etc
			std::string Filename = HLE_IPC_BuildFilename((const char*)Memory::GetPointer(_BufferIn), 64);
			u8 OwnerPerm = 0x3;   // read/write
			u8 GroupPerm = 0x3;   // read/write
			u8 OtherPerm = 0x3;   // read/write
			u8 Attributes = 0x00; // no attributes
			if (File::IsDirectory(Filename))
			{
				INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR Directory %s - all permission flags are set", Filename.c_str());
			}
			else
			{
				if (File::Exists(Filename))
				{
					INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR %s - all permission flags are set", Filename.c_str());
				}
				else
				{
					INFO_LOG(WII_IPC_FILEIO, "FS: GET_ATTR unknown %s", Filename.c_str());
					return FS_FILE_NOT_EXIST;
				}
			}

			// write answer to buffer
			if (_BufferOutSize == 76)
			{
				u32 Addr = _BufferOut;
				Memory::Write_U32(OwnerID, Addr);                                    Addr += 4;
				Memory::Write_U16(GroupID, Addr);                                    Addr += 2;
				memcpy(Memory::GetPointer(Addr), Memory::GetPointer(_BufferIn), 64); Addr += 64;
				Memory::Write_U8(OwnerPerm, Addr);                                   Addr += 1;
				Memory::Write_U8(GroupPerm, Addr);                                   Addr += 1;
				Memory::Write_U8(OtherPerm, Addr);                                   Addr += 1;
				Memory::Write_U8(Attributes, Addr);                                  Addr += 1;
			}

			return FS_RESULT_OK;
		}
		break;


	case IOCTL_DELETE_FILE:
		{
			_dbg_assert_(WII_IPC_FILEIO, _BufferOutSize == 0);
			int Offset = 0;

			std::string Filename = HLE_IPC_BuildFilename((const char*)Memory::GetPointer(_BufferIn+Offset), 64);
			Offset += 64;
			if (File::Delete(Filename))
			{
				INFO_LOG(WII_IPC_FILEIO, "FS: DeleteFile %s", Filename.c_str());
			}
			else if (File::DeleteDir(Filename))
			{
				INFO_LOG(WII_IPC_FILEIO, "FS: DeleteDir %s", Filename.c_str());
			}
			else
			{
				WARN_LOG(WII_IPC_FILEIO, "FS: DeleteFile %s - failed!!!", Filename.c_str());
			}

			return FS_RESULT_OK;
		}
		break;

	case IOCTL_RENAME_FILE:
		{
			_dbg_assert_(WII_IPC_FILEIO, _BufferOutSize == 0);
			int Offset = 0;

			std::string Filename = HLE_IPC_BuildFilename((const char*)Memory::GetPointer(_BufferIn+Offset), 64);
			Offset += 64;

			std::string FilenameRename = HLE_IPC_BuildFilename((const char*)Memory::GetPointer(_BufferIn+Offset), 64);
			Offset += 64;

			// try to make the basis directory
			File::CreateFullPath(FilenameRename);

			// if there is already a file, delete it
			if (File::Exists(Filename) && File::Exists(FilenameRename))
			{
				File::Delete(FilenameRename);
			}

			// finally try to rename the file
			if (File::Rename(Filename, FilenameRename))
			{
				INFO_LOG(WII_IPC_FILEIO, "FS: Rename %s to %s", Filename.c_str(), FilenameRename.c_str());
			}
			else
			{
				ERROR_LOG(WII_IPC_FILEIO, "FS: Rename %s to %s - failed", Filename.c_str(), FilenameRename.c_str());
				return FS_FILE_NOT_EXIST;
			}

			return FS_RESULT_OK;
		}
		break;

	case IOCTL_CREATE_FILE:
		{
			_dbg_assert_(WII_IPC_FILEIO, _BufferOutSize == 0);

			u32 Addr = _BufferIn;
			u32 OwnerID = Memory::Read_U32(Addr); Addr += 4;
			u16 GroupID = Memory::Read_U16(Addr); Addr += 2;
			std::string Filename(HLE_IPC_BuildFilename((const char*)Memory::GetPointer(Addr), 64)); Addr += 64;
			u8 OwnerPerm = Memory::Read_U8(Addr); Addr++;
			u8 GroupPerm = Memory::Read_U8(Addr); Addr++;
			u8 OtherPerm = Memory::Read_U8(Addr); Addr++;
			u8 Attributes = Memory::Read_U8(Addr); Addr++;

			INFO_LOG(WII_IPC_FILEIO, "FS: CreateFile %s", Filename.c_str());
			DEBUG_LOG(WII_IPC_FILEIO, "    OwnerID: 0x%08x", OwnerID);
			DEBUG_LOG(WII_IPC_FILEIO, "    GroupID: 0x%04x", GroupID);
			DEBUG_LOG(WII_IPC_FILEIO, "    OwnerPerm: 0x%02x", OwnerPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    GroupPerm: 0x%02x", GroupPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    OtherPerm: 0x%02x", OtherPerm);
			DEBUG_LOG(WII_IPC_FILEIO, "    Attributes: 0x%02x", Attributes);

			// check if the file already exist
			if (File::Exists(Filename))
			{
				WARN_LOG(WII_IPC_FILEIO, "\tresult = FS_RESULT_EXISTS");
				return FS_FILE_EXIST;
			}

			// create the file
			File::CreateFullPath(Filename);  // just to be sure
			bool Result = File::CreateEmptyFile(Filename);
			if (!Result)
			{
				ERROR_LOG(WII_IPC_FILEIO, "CWII_IPC_HLE_Device_fs: couldn't create new file");
				PanicAlert("CWII_IPC_HLE_Device_fs: couldn't create new file");
				return FS_RESULT_FATAL;
			}

			INFO_LOG(WII_IPC_FILEIO, "\tresult = FS_RESULT_OK");
			return FS_RESULT_OK;
		}
		break;
	case IOCTL_SHUTDOWN:
		{
			INFO_LOG(WII_IPC_FILEIO, "Wii called Shutdown()");
			// TODO: stop emulation
		}
		break;
	default:
		ERROR_LOG(WII_IPC_FILEIO, "CWII_IPC_HLE_Device_fs::IOCtl: ni  0x%x", _Parameter);
		PanicAlert("CWII_IPC_HLE_Device_fs::IOCtl: ni  0x%x", _Parameter);
		break;
	}

	return FS_RESULT_FATAL;
}
Exemplo n.º 4
0
Bool DiffDistriDialog::Command(Int32 id, const BaseContainer &msg)
{
	switch (id)
	{
	case IDC_DIFF_DISTRI_NEW_BTN:
		{
			Filename fn;
			if (fn.FileSelect(FILESELECTTYPE_ANYTHING, FILESELECT_LOAD, GeLoadString(IDS_DIFF_DISTRI_CHOOSE)))
			{
				if (!fn.CheckSuffix("zip"))
				{
					GeOutString(GeLoadString(IDS_DIFF_DISTRI_INVALID_SUFFIX), GEMB_OK | GEMB_ICONSTOP);
				}
				else
				{
					g_pResEditPrefs->arOldFiles.AddFilename(fn);
					m_pTreeView->Refresh();
				}
			}
		}
		break;

	case IDC_DIFF_DISTRI_REMOVE_BTN:
		if (m_fnSelection.Content())
		{
			g_pResEditPrefs->arOldFiles.RemoveFilename(m_fnSelection);
			m_fnSelection = Filename();
			m_pTreeView->Refresh();
		}
		break;

	case IDC_DIFF_DISTRI_NEWZIP_EDIT:
		g_pResEditPrefs->fnNewZip = m_pNewZipEdit->GetData().GetValue().GetFilename();
		break;

	case IDC_DIFF_DISTRI_DESTPATH_EDIT:
		{
			Filename fnDestZip = m_pDestPathEdit->GetData().GetValue().GetFilename();
			g_pResEditPrefs->fnDestZip = fnDestZip;
			g_pResEditPrefs->fnDestZip.SetSuffix("zip");
			if (fnDestZip.Content() && g_pResEditPrefs->fnDestZip != fnDestZip)
				m_pDestPathEdit->SetData(TriState<GeData>(g_pResEditPrefs->fnDestZip));
		}
		break;

	case IDC_OK:
		{
			GeData d;
			String strPassword;
			Int32 lLen = 0;
			char* pchPassword = nullptr;

			Filename fnDestZip = m_pDestPathEdit->GetData().GetValue().GetFilename();
			g_pResEditPrefs->fnNewZip = m_pNewZipEdit->GetData().GetValue().GetFilename();
			g_pResEditPrefs->fnDestZip = fnDestZip;
			g_pResEditPrefs->fnDestZip.SetSuffix("zip");
			if (fnDestZip.Content() && g_pResEditPrefs->fnDestZip != fnDestZip)
				m_pDestPathEdit->SetData(TriState<GeData>(g_pResEditPrefs->fnDestZip));
			GetString(IDC_DIFF_DISTRI_PASSWORD_EDIT, strPassword);

			lLen = strPassword.GetCStringLen(STRINGENCODING_8BIT);
			if (lLen)
			{
				pchPassword = NewMemClear(Char,lLen + 2);
				if (pchPassword)
					strPassword.GetCString(pchPassword, lLen + 1, STRINGENCODING_8BIT);
			}

			if (!g_pResEditPrefs->arOldFiles.GetElementCount())
			{
				GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_OLD), GEMB_ICONSTOP);
				DeleteMem(pchPassword);
				break;
			}
			if (!g_pResEditPrefs->fnNewZip.Content())
			{
				GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_NEW), GEMB_ICONSTOP);
				DeleteMem(pchPassword);
				break;
			}
			if (!g_pResEditPrefs->fnDestZip.Content())
			{
				GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_DEST), GEMB_ICONSTOP);
				DeleteMem(pchPassword);
				break;
			}

			if (!DiffZipFiles(g_pResEditPrefs->arOldFiles, g_pResEditPrefs->fnNewZip, g_pResEditPrefs->fnDestZip, pchPassword))
				GeOutString(GeLoadString(IDS_DIFF_DISTRI_FAILED, g_pResEditPrefs->fnNewZip.GetString(), g_pResEditPrefs->fnDestZip.GetString()), GEMB_OK | GEMB_ICONEXCLAMATION);
			DeleteMem(pchPassword);
		}
		break;

	case IDC_CANCEL:
		Close();
		break;

	default:
		break;
	}

	return true;
}
Exemplo n.º 5
0
void HiJitCube::Init() throw (iException &) {
   // Get required keywords from instrument group
  Pvl *label(Label());
  Isis::PvlGroup inst;
  Isis::PvlGroup idinst;
  jdata.filename = Filename();
  Isis::PvlGroup &archive = label->FindGroup ("Archive",Isis::Pvl::Traverse);
  jdata.productId = (string) archive["ProductId"];

  jdata.lines = Lines();
  if (label->FindObject("IsisCube").HasGroup("OriginalInstrument")) {
    inst = label->FindGroup ("OriginalInstrument",Isis::Pvl::Traverse);
    originst = true;
  } else {
    inst = label->FindGroup ("Instrument",Isis::Pvl::Traverse);
    originst = false;
  }
  jdata.tdiMode = inst["Tdi"];
  jdata.summing = inst["Summing"];
  if (label->FindObject("IsisCube").HasGroup("Instrument") && originst) {
    idinst = label->FindGroup ("Instrument",Isis::Pvl::Traverse);
    jdata.pixpitch = idinst["PixelPitch"];
    jdata.summing = (int) (jdata.pixpitch/.012);
  }
  if (originst && jdata.summing != 1 && !sampinit) {
    for (int i=0; i<14; i++) {
      npSamps[i] = (int) (npSamps[i]/(float)jdata.summing + 0.5);
      npSamp0[i] = (int) (npSamp0[i]/(float)jdata.summing + 0.5);
    }
    sampinit = true;
  }
  jdata.channelNumber = inst["ChannelNumber"];
  jdata.cpmmNumber = inst["CpmmNumber"];
  if (originst) {
    jdata.samples = npSamps[jdata.cpmmNumber];
  } else {
    jdata.samples = Samples();
  }
  jdata.ccdName = Instrument::CCD_NAMES[jdata.cpmmNumber];
  jdata.dltCount = inst["DeltaLineTimerCount"];
  jdata.UTCStartTime = (string) inst["StartTime"];
  jdata.scStartTime = (string) inst["SpacecraftClockStartCount"];

  try {
      if (originst) {
        jdata.fpSamp0 = npSamp0[jdata.cpmmNumber];
      } else {
        jdata.fpSamp0 = Instrument::focal_plane_x_offset(jdata.cpmmNumber,
	                                               jdata.summing);
      }
  } catch (Exception hiExc) {
    ostringstream msg;
    msg << "Summing mode (" << jdata.summing 
        << ") is illegal (must be > 0) or CPMM number (" << jdata.cpmmNumber
        << ") is invalid in file " << Filename() << endl;
    throw iException::Message(iException::User,msg.str(),_FILEINFO_);
  }

//  It is assumed all images start at the line location in the focal plane
  jdata.fpLine0 = 0;

//  Validate channel number and adjust starting sample
  if ((jdata.channelNumber > 2) || (jdata.channelNumber < 0)) {
    ostringstream msg;
    msg << "Channel number (" << jdata.channelNumber 
        << ") is invalid (must be 0, 1 or 2) in file " << Filename() << endl;
    throw iException::Message(iException::User,msg.str(),_FILEINFO_);
  }
  else {
    if (originst) {
      if (jdata.channelNumber == 0) jdata.fpSamp0 += npSamps[jdata.cpmmNumber];
    } else {
      if (jdata.channelNumber == 0) jdata.fpSamp0 += Samples();
    }
  }

// Determine starting time of image and compute the binning rates
  computeStartTime();

//  Compute the focal plane polygon for this image
  computePoly();
  return;
}
Exemplo n.º 6
0
void main()
{
	
	//vector<wstring> vFileNames = get_files_name(L"C:\\Users\\김송란\\Desktop\\송란이폴더\\랩세미나\\201603\\MunjaDB_IMG20160323\\*.bmp");
	//vector<wstring> vFileNames = get_files_name(L"C:\\Users\\김송란\\Desktop\\송란이폴더\\랩세미나\\201603\\test\\*.bmp");
	vector<wstring> vFileNames = get_files_name(L"C:\\Users\\김송란\\Documents\\GitHub\\MIPlab_seminar\\character recognition\\character recognition\\*.bmp");

	//char *str;
	//sprintf(str, "%ls", vFileNames[0].c_str());
	//wcout << vFileNames.size() << endl;
	//for (int i = 0; i < vFileNames.size(); i++)
	//{
	//	wcout << vFileNames[i] << endl;
	//}
	//int width, height;
	
	CHARACTER *Database_Char=(CHARACTER *)calloc(vFileNames.size(), sizeof(CHARACTER));
	CHARACTER charname[50];
	int a,b;
	string nameout;
	string test;
	vector<vector< string> > featureArr(600, vector<string>(600));
	int file_count = vFileNames.size();
	for (int i = 0; i < vFileNames.size(); i++)
	{
		test = CW2A(vFileNames[i].c_str());//wstring->string
		Mat A = imread(test, IMREAD_GRAYSCALE);
		// 파일명에서 알파벳 추출
		a = test.find('[');
		b = test.find(']');
		nameout = test.substr(a + 1, b-a-1);
		Database_Char[i].shape = nameout;
 		Char_Feature(A,A.rows,A.cols, Database_Char[i]);//샘플특징	
		//int y = (int)(Database_Char[i].ratey * 100);
		//int x = (int)(Database_Char[i].ratex * 100);
		//featureArr[y][x] = Database_Char[i].shape;	
	}
	Filename(file_count, Database_Char, charname); //중복되는 문자 하나로
	Char_Feature_avg(charname, file_count, Database_Char);// 특징평균값

	for (int i = 0; i < 50; i++)
	{
		cout << charname[i].shape<<"          "<< charname[i].ratex << "  " << charname[i].ratey <<" / "<< charname[i].avg1<< " / "<< charname[i].avg2<<" / "<< charname[i].avg3<<" / "<< charname[i].avg4<<endl;
	}

	int Optnum;
	CHARACTER input_Char;
	//string temp;
	//vector<wstring> inputfilenames = get_files_name(L"C:\\Users\\김송란\\Documents\\GitHub\\MIPlab_seminar\\character recognition\\character recognition\\*.bmp");
	char dbname[200];
	for (int i = 1; i <89; i++)
	{
		//sprintf(dbname, "C:\\Users\\김송란\\Documents\\카카오톡 받은 파일\\문자추출\\test%03d.bmp", i);
		sprintf(dbname, "C:\\Users\\김송란\\Documents\\카카오톡 받은 파일\\문자추출리사이즈\\resize%03d.bmp", i);
		Mat B = imread(dbname, IMREAD_GRAYSCALE);
		Char_Feature(B, B.rows, B.cols, input_Char);
		OptSample(charname, input_Char, &Optnum);
		cout << i << "  입력문자는 " << charname[Optnum].shape << "특징 - "<<charname[Optnum].avg1<< " / "<< charname[Optnum].avg2<<" / "<< charname[Optnum].avg3<<" / "<< charname[Optnum].avg4<<endl;
	}


	
	//CHARACTER input_Char;
	//Mat B = imread("C:\\Users\\김송란\\Documents\\GitHub\\MIPlab_seminar\\character recognition\\lineImg.bmp", IMREAD_GRAYSCALE); //입력 이미지
	//Binary(B);
	////imshow("input", B);
	////waitKey(0);
	//
	////라벨링
	//Mat labelImage(B.rows, B.cols, CV_16UC1);
	//int label_count=connectedComponents(B, labelImage, 8); // 0까지 포함된 갯수임
	////imwrite("label.bmp", labelImage);
	//


	//int y_max[255] = { 0 }, x_max[255] = { 0 };
	//int y_min[255], x_min[255];
	//for (int i = 0; i < 255; i++)
	//{
	//	y_min[i] = B.rows;
	//	x_min[i] = B.cols;
	//}
	//
	//Mat C(B.rows, B.cols, CV_8UC1);
	//for (int i = 0; i < B.rows; i++)
	//	for (int j = 0; j < B.cols; j++)
	//	{
	//		C.at<unsigned char>(i, j) = B.at<unsigned char>(i, j);
	//	}
	//
	//Find_MaxMin(labelImage, y_max, x_max, y_min, x_min);
	//MakingBox(labelImage, C,B, y_max, x_max, y_min, x_min, label_count);



	//imwrite("abc.bmp", C);
	//imshow("output", B);
	//waitKey(0);
	/*
	Char_Feature(B, B.rows, B.cols, input_Char);
	int y = (int)(input_Char.ratey * 100);
	int x = (int)(input_Char.ratex * 100);
	double err1, err2;
	double min_err1 = 100.0, min_err2 = 100.0;
	int c, d;
	for (int i = y - 10; i <= y + 10; i++)
		for (int j = x - 10; j <= x + 10; j++)
		{
			if (featureArr[i][j] != NULL)
			{
				err1 = abs(y - i);
				if (err1 < min_err1)
				{
					min_err1 = err1;
					err2 = abs(x - j);
					if (err2 < min_err2)
					{
						min_err2 = err2;
						c= i;
						d = j;
					}
				}

			}
			else
				cout << "없음" << endl;
		}
	cout << featureArr[c][d] << endl;
	*/
	
	//구조체 전달 확인
	//opt_num=OptSample(Database_Char, input_Char,min_err,file_count);
		
	
	
	
	
	
}
Exemplo n.º 7
0
/*********************************************************************\
	Function name    : CResEditBrowser::Command
	Description      :
	Created at       : 25.09.01, @ 22:33:39
	Created by       : Thomas Kunert
	Modified by      :
\*********************************************************************/
Bool CResEditBrowser::Command(Int32 lID, const BaseContainer &msg)
{
	switch (lID)
	{
	case IDC_BROWSE_BUTTON: {
		Filename fn = m_strPath;
		AutoAlloc <BrowseFiles> pFiles;
		pFiles->Init(Filename("\\"), false);
		if (!m_strPath.Content())
			fn = GeGetStartupPath() + String("resource");
		if (fn.FileSelect(FILESELECTTYPE_ANYTHING, FILESELECT_DIRECTORY, GeLoadString(IDS_SPECIFY_RES_PATH)))
		{
			m_strPath = fn;
			FillList();
		}
		break;
	}
	case IDC_DIRECTORY_TREE: {
		TreeViewItem* pSelItem = (TreeViewItem*)msg.GetVoid(TREEVIEW_MESSAGE_ITEM);
		Int32 lType = msg.GetInt32(TREEVIEW_MESSAGE_TYPE);
		if (!pSelItem) break;

		if (lType == TREEVIEW_DOUBLECLICK)
		{
			Filename fn = pSelItem->GetData()->GetString(ITEM_PATH_NAME);
			if (fn.CheckSuffix("res"))
			{
				// open the resource file
				if (!g_bWasActive)
				{ CResEditMenu m; m.Execute(nullptr); }
				if (!g_pTreeDialog) break;
				g_pTreeDialog->OpenDialog(fn);
			}
			else if (fn.CheckSuffix("str"))
			{
				CDialogDoc tempDoc;
				tempDoc.LoadGlobalStringTable(m_strPath, pSelItem->GetData()->GetString(TREEVIEW_TEXT));
				CStringtableDialog dlg(&tempDoc, true);
				if (dlg.Open())
				{
					if (GeOutString(GeLoadString(IDS_SAVE_STRINGTABLE), GEMB_YESNO | GEMB_ICONQUESTION) == GEMB_R_YES)
					{
						tempDoc.SaveGlobalStringTable();
					}
				}
			}
			else if (fn.Content())
			{
				// open the file (it may be an image)
				GeExecuteFile(fn);
			}
			return true;
		}
		else if (lType == TREEVIEW_SELCHANGE)
		{
			m_dirText = pSelItem->GetData()->GetString(ITEM_PATH_NAME);
		}

		break;
	}
	};
	return GeDialog::Command(lID, msg);
}
Exemplo n.º 8
0
void FilenameTest::testIsValid()
{
	QCOMPARE(Filename("").isValid(), false);
	QCOMPARE(Filename("%md5%").isValid(), false);
	QCOMPARE(Filename("toto").isValid(), false);
	QCOMPARE(Filename("%toto% %md5%.%ext%").isValid(), false);
	QCOMPARE(Filename("%md5%.%ext%").isValid(), true);
	QCOMPARE(Filename("%id%.%ext%").isValid(), false);
	QCOMPARE(Filename("%website%/%id%.%ext%").isValid(), true);
	QCOMPARE(Filename("%artist%/%copyright%/%character%/%md5%.%ext%").isValid(), true);
	QCOMPARE(Filename("javascript:md5 + '.' + ext;").isValid(), true);
	QCOMPARE(Filename("%md5% %date:format=yyyy-MM-dd%.%ext%").isValid(), true);

	QString out;
	Filename("%toto%.%ext%").isValid(&out);
	QCOMPARE(out.isEmpty(), false);
}
int main()
{
	std::cout << "###############################################" << std::endl;
	std::cout << "Running Shader AutoCompile...\n\n";

	char aShaderDir[] = "Shader ASM\\*";

	std::ofstream ShaderHeader("include\\Shader.h");
	ShaderHeader << "// Auto generated shader opcodes\n\n";

	WIN32_FIND_DATA	FData;
	HANDLE			hSearch = FindFirstFile(aShaderDir, &FData);
	do
	{
		if(FData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
			continue;

		// get ending
		std::string Filename(FData.cFileName);
		std::string Ending = Filename.substr(Filename.find_last_of('.')+1);
		std::string FileWithoutEnding = Filename.substr(0, Filename.find_last_of('.'));

		if(Ending == "psh" || Ending == "vsh")
		{
			bool PixelShader = Ending == "psh";
			if(PixelShader)
				std::cout << "Found Pixelshader \"" << FData.cFileName << "\" .. compiling .." << std::endl;
			else
				std::cout << "Found Vertexshader \"" << FData.cFileName << "\" .. compiling .." << std::endl;

			ShaderHeader << "// " << Filename << ":" << std::endl;

			LPD3DXBUFFER pBuffer = nullptr;
			LPD3DXBUFFER pErrors = nullptr;
			D3DXAssembleShaderFromFile((std::string("Shader ASM\\") + FData.cFileName).c_str(), 0, 0, D3DXSHADER_OPTIMIZATION_LEVEL1, &pBuffer, &pErrors);

			if(pErrors == nullptr && pBuffer)
			{
				std::cout << "Succeded!" << std::endl;

				
				ShaderHeader << "const DWORD g_a" << FileWithoutEnding  << (PixelShader ? "PS" : "VS") << "[] = { ";
				DWORD* pDWORDs = static_cast<DWORD*>(pBuffer->GetBufferPointer());
				unsigned int NumTocken = pBuffer->GetBufferSize() / sizeof(DWORD);
				for(unsigned int i=0; i<NumTocken-1; ++i)
					ShaderHeader << pDWORDs[i] << ", ";
				ShaderHeader << pDWORDs[NumTocken-1] << " };\n\n";

			}
			else
			{
				if(pErrors)
					std::cout << "Some errors occured:\n" << static_cast<char*>(pErrors->GetBufferPointer()) << std::endl << std::endl;
				else
					std::cout << "Some errors occured: - No description - \n\n";
			}

			std::cout << std::endl;
		}

	} while(FindNextFile(hSearch,&FData));

	ShaderHeader.close();

	std::cout << "Shader AutoCompile finished!" << std::endl;
	std::cout << "###############################################\n\n";
}
Exemplo n.º 10
0
BOOL ringFile::moveTo(LPCTSTR lpNewName,BOOL bForceOverWrite)
{
	if(m_bExtern || lpNewName == NULL || *lpNewName == '\0')
		return FALSE;

	char	dbuf[MAX_PATH];
	DWORD	attr = GetFileAttributes(lpNewName);
	
	if((attr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
	{
		if(lpNewName[strlen(lpNewName)-1] == '\\')
			wsprintf(dbuf,"%s%s\0\0",lpNewName,Filename());
		else
			wsprintf(dbuf,"%s\\%s\0\0",lpNewName,Filename());
	}
	else
		strcpy(dbuf,lpNewName);

	DWORD	how = bForceOverWrite?MOVEFILE_REPLACE_EXISTING:0;

	DWORD	loc    = 0UL;
	BOOL bOpened = (BOOL)m_hFile;
	// 如果文件处于打开状态,则先关闭它
	if(m_hFile)
	{
		loc = GetRWLocation();
		Close();
	}

	// 移动文件
	BOOL bOK;
	
	if(OSType() == OST_WINNT)
		bOK = ::MoveFileEx(m_szFilename,dbuf,how);
	else
	{
		bOK = copyTo(dbuf,how);//ringFile rf = dbuf;
		if(bOK)
			delIt();
	}

	// 如果移动失败,恢复原状态
	if(!bOK)
	{
		if(bOpened)
		{
			Open(RF_READWRITE);
			Seek(loc);
		}
		return FALSE;
	}

	// 关联到新的位置
	SetFile(dbuf);

	if(bOpened)
	{
		Open(RF_READWRITE);
		Seek(loc);		
	}

	return TRUE;
}