void handleSetFlywheelBool(char const *request, FlywheelBoolAcceptor accept) { if (stringStartsWith("true", request)) { accept(flywheel, true); } else if (stringStartsWith("false", request)) { accept(flywheel, false); } }
bool parseArgs(AcceptArgs& args, int argc, char** argv) { bool hasOutName = false, hasInName = false; for(int i = 1;i < argc;++i) { if(strcmp(argv[i], "-a") == 0) { args.convertAll = true; break; } else if(strcmp(argv[i], "-t") == 0) { args.convertAscii = true; } else if(stringStartsWith(argv[i], "in:")) { hasInName = true; args.src_file = argv[i]; args.src_file = args.src_file.substr(3,std::string::npos); } else if(stringStartsWith(argv[i], "out:")) { hasOutName = true; args.dst_file = argv[i]; args.dst_file = args.dst_file.substr(4,std::string::npos); } } if(args.convertAll || hasInName) { if(!hasOutName) { if(stringEndsWith(args.src_file, ".fbx")) args.dst_file = args.src_file.substr(0,args.src_file.length() - 4); } else { //titan binary mesh, titan ascii mesh if(stringEndsWith(args.dst_file, ".tbm") || stringEndsWith(args.dst_file, ".tam")) args.dst_file = args.dst_file.substr(0,args.dst_file.length() - 4); } } else return false; return true; }
void handleRequest(const HandlerMap *api, const size_t apiSize, char const *request) { size_t requestLength = strlen(request); size_t keyLength; for (int i = 0; i < apiSize; i++) { keyLength = strlen(api[i].key); if (!(stringStartsWith(api[i].key, request) && requestLength > keyLength)) { //printf("Debug Not a %s request.\n", api[i].key); continue; } if (!isspace((unsigned char)request[keyLength])) { //printf("Debug Not a %s request.\n", api[i].key); continue; } //printf("Debug %s request.\n", api[i].key); int spaces = 0; while (isspace((unsigned char)request[keyLength + spaces])) { ++spaces; } //printf("Debug Gottit, passing the request down.\n"); api[i].handler(request + keyLength + spaces); break; } }
/* * Given the user command line input of either a number or a plan name, * decide what the proper power plan to run should be. */ static int planFromOptArg(char *const arg) { const std::string convertedArg(arg); int plan; if (convertedArg.compare("1") == 0 || stringStartsWith("powersave", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Plan is powersave" << std::endl; } plan = Values::POWER_PLAN_POWERSAVE; } else if (convertedArg.compare("2") == 0 || stringStartsWith("performance", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Plan is performance" << std::endl; } plan = Values::POWER_PLAN_PERFORMANCE; } else if (convertedArg.compare("3") == 0 || stringStartsWith("max-performance", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Plan is max-performance" << std::endl; } plan = Values::POWER_PLAN_MAX_PERFORMANCE; } else if (convertedArg.compare("0") == 0 || stringStartsWith("auto", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Plan is auto" << std::endl; } plan = Values::POWER_PLAN_AUTO; } else { if (!Log::isAllQuiet()) { printPlanHelp(); } return Values::POWER_PLAN_NONE; } return plan; }
void handleSetController(char const *request) { ControllerType controllerType; if (stringStartsWith("PID", request)) { controllerType = CONTROLLER_TYPE_PID; } else if (stringStartsWith("TBH", request)) { controllerType = CONTROLLER_TYPE_TBH; } else if (stringStartsWith("Bang-bang", request)) { controllerType = CONTROLLER_TYPE_BANG_BANG; } else { return; } flywheelSetController(flywheel, controllerType); }
/* * Given the user input which is a governor name, and the list of currently * available governors, decide on the governor to set or none if the user * requested input is a value which does not exist on the system. */ static const std::string governorFromOptArg(char *const arg, const std::vector<std::string> &availableGovernors) { const std::string convertedArg(arg); std::string governor; for (unsigned int i = 0; i < availableGovernors.size(); ++i) { if (stringStartsWith(availableGovernors[i], convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] valid governor found: " << availableGovernors[i] << std::endl; } governor = availableGovernors[i]; break; } } if (governor == UNINITIALIZED_STR) { for (unsigned int i = 0; i < availableGovernors.size(); ++i) { if (convertedArg.compare(numberToString(i)) == 0) { if (Log::isDebug()) { std::cout << "[Debug] valid governor " << "found: " << availableGovernors[i] << std::endl; } governor = availableGovernors[i]; break; } } } if (governor == UNINITIALIZED_STR) { if (!Log::isAllQuiet()) { printGovernorHelp(availableGovernors); } return UNINITIALIZED_STR; } else { return governor; } }
// function to serialise AnyType and return pointer to buffer // containing data in serial form void *serialiseAnyType(AnyTypePNTR data, int *size){ void *serial_buffer; FunctionPairPNTR funcs = mapGet(serialiserMap, data->type); if (funcs == NULL || funcs->ser == NULL){ DAL_error(SERIALISATION_ERROR); PRINTF("serAny:%s \n", (char *) data->type); return NULL; } //PRINTF(" serany: %s \n", data->type); if(stringStartsWith(data->type, "i") || stringStartsWith(data->type, "e")) serial_buffer = (*(funcs->ser))(&(data->value.int_value), size); else if(stringStartsWith(data->type, "u")) serial_buffer = (*(funcs->ser))(&(data->value.unsigned_value), size); else if(stringStartsWith(data->type, "r")) serial_buffer = (*(funcs->ser))(&(data->value.real_value), size); else if(stringStartsWith(data->type, "b")) serial_buffer = (*(funcs->ser))(&(data->value.bool_value), size); else if(stringStartsWith(data->type, "8")) serial_buffer = (*(funcs->ser))(&(data->value.byte_value), size); else serial_buffer = (*(funcs->ser))(data->value.pointer_value, size); return serial_buffer; }
char * ChannelReceivingThread::processFlags (char *inMessageID, char *inFromAddress, char *inOldFlags, char *outIgnoreUC, char *outDropMessage, char *inLoggerName) { char *flags = stringDuplicate (inOldFlags); *outIgnoreUC = false; *outDropMessage = false; // first, check if message should be signed // addresses starting with PKH are hashes of sender's public key if (stringStartsWith (inFromAddress, "PKH")) { // make sure hash in address matches attatched public key // get public key char *pubKey = getFlagData (flags, "PUBLIC_KEY_"); if (pubKey == NULL) { AppLog::detail (inLoggerName, "Message from a PKH address does not have a PUBLIC_KEY flag." " Dropping."); *outDropMessage = true; return flags; } // get signature char *signedID = getFlagData (flags, "SIGNED_ID_"); if (pubKey == NULL) { AppLog::detail (inLoggerName, "Message from a PKH address does not have a SIGNED_ID flag." " Dropping."); delete[]pubKey; *outDropMessage = true; return flags; } char *trueKeyHash = computeSHA1Digest (pubKey); // skip "PKH" in address to get to key hash char *hashInAddress = &(inFromAddress[3]); int trueHashToAddressHashCompare = strcmp (trueKeyHash, hashInAddress); delete[]trueKeyHash; if (trueHashToAddressHashCompare != 0) { AppLog::detail (inLoggerName, "PUBLIC_KEY hash does not match hash from PKH address." " Dropping."); delete[]pubKey; *outDropMessage = true; return flags; } // we have a pubkey that matches the from address // and we have already extracted the signature above // check the signature char signatureCorrect = CryptoUtils::rsaVerify (pubKey, (unsigned char *) inMessageID, strlen (inMessageID), signedID); delete[]pubKey; delete[]signedID; if (!signatureCorrect) { AppLog::detail (inLoggerName, "Bad signature on message from a PKH address." " Dropping."); *outDropMessage = true; return flags; } } // process a FORWARD flag char *pointerToForwardFlag = strstr (flags, "FORWARD_"); if (pointerToForwardFlag != NULL) { // message has forward flag // extract the hash from the forward flag char *oldForwardFlag = stringDuplicate (pointerToForwardFlag); char *pointerToFlagSeparator = strstr (oldForwardFlag, "|"); if (pointerToFlagSeparator != NULL) { // terminate string at separator pointerToFlagSeparator[0] = '\0'; } // skip FORWARD_ to get to the hash char *pointerToHash = &(oldForwardFlag[strlen ("FORWARD_")]); // re-hash the hash to produce a new hash char *newHash = muteComputeNewForwardHash (pointerToHash); if (newHash != NULL) { // continue forwarding *outIgnoreUC = true; char *newForwardFlag = autoSprintf ("FORWARD_%s", newHash); // replace old flag with new one char *tempFlags = muteRemoveFlag (flags, oldForwardFlag); char *newFlags = muteAddFlag (tempFlags, newForwardFlag); delete[]tempFlags; delete[]flags; delete[]newForwardFlag; flags = newFlags; delete[]newHash; } else { // we're breaking the forward tree *outIgnoreUC = false; // remove the forward flag char *newFlags = muteRemoveFlag (flags, oldForwardFlag); delete[]flags; flags = newFlags; AppLog::detail (inLoggerName, "Breaking the FORWARD tree."); } delete[]oldForwardFlag; } // process a DROP_TTL flag char *pointerToDropTTLFlag = strstr (flags, "DROP_TTL_"); if (pointerToDropTTLFlag != NULL) { // message has drop TTL flag // extract the hash from the dropTTL flag char *oldDropTTLFlag = stringDuplicate (pointerToDropTTLFlag); char *pointerToFlagSeparator = strstr (oldDropTTLFlag, "|"); if (pointerToFlagSeparator != NULL) { // terminate string at separator pointerToFlagSeparator[0] = '\0'; } // skip DROP_TTL_ to get to the TTL value char *pointerToTTLValue = &(oldDropTTLFlag[strlen ("DROP_TTL_")]); int ttlValue; int numRead = sscanf (pointerToTTLValue, "%d", &ttlValue); if (numRead == 1) { ttlValue--; if (ttlValue <= 0) { *outDropMessage = true; AppLog::detail (inLoggerName, "Breaking the DROP_TTL tree, since the TTL reached 0."); } else { char *newDropTTLFlag = autoSprintf ("DROP_TTL_%d", ttlValue); // replace old flag with new one char *tempFlags = muteRemoveFlag (flags, oldDropTTLFlag); char *newFlags = muteAddFlag (tempFlags, newDropTTLFlag); delete[]tempFlags; delete[]flags; delete[]newDropTTLFlag; flags = newFlags; } // ignore the UC in drop mode *outIgnoreUC = true; } delete[]oldDropTTLFlag; } // process a DROP_CHAIN flag char *pointerToDropChainFlag = strstr (flags, "DROP_CHAIN"); if (pointerToDropChainFlag != NULL) { // message has drop chain flag // ignore UCs on all DROP tail messages *outIgnoreUC = true; if (muteShouldDropTailChainMessages ()) { *outDropMessage = true; AppLog::detail (inLoggerName, "Breaking the DROP_CHAIN."); } } return flags; }
char * getHTML() { bstring html = bfromcstr("<!DOCTYPE html>\n<html>\n"); balloc(html, style_css_len); bcatcstr(html, "<head>"); bcatcstr(html, "<title>mdr</title>"); bcatcstr(html, "<style type='text/css'>"); bcatcstr(html, (char *)style_css); bcatcstr(html, "</style>"); bcatcstr(html, "</head>"); bcatcstr(html, "<body>\n<table cellpadding='0'>\n"); // Read from stdin bstring stdinContents = bread ((bNread) fread, stdin); if (stdinContents == NULL) { return "There was an error reading from stdin."; } // Split into lines struct bstrList * inputLines; if ((inputLines = bsplit(stdinContents, '\n')) != NULL) { // We are going to build a map showing which lines in the input belong // in which lines in the output and how they should be displayed. We'll // allocate the left and right maps to be big enough to each hold all // the input data, which is more than enough. lineData * lineMapL = malloc(inputLines->qty * sizeof(lineData)); if (lineMapL == NULL) { free(lineMapL); printf("Memory allocation error.\n"); exit(-1); } lineData * lineMapR = malloc(inputLines->qty * sizeof(lineData)); if (lineMapR == NULL) { free(lineMapR); printf("Memory allocation error.\n"); exit(-1); } int lineMapPosL = 0; int lineMapPosR = 0; int useL; int useR; enum lineType type; int padding; int lineNoL = 0; int lineNoR = 0; int firstInfoLine = TRUE; int startNewFileOk = TRUE; int startOldFileOk = TRUE; // Map input lines to their output column (left, right, or both) int i; for (i = 0; i < inputLines->qty; i++) { useL = 0; useR = 0; type = SHARED; padding = 1; if (startOldFileOk && stringStartsWith(inputLines->entry[i], "---")) { type = OLD_FILE; useL = 1; padding = 4; lineNoL = -1; lineNoR = -1; startOldFileOk = FALSE; } else if (startNewFileOk && stringStartsWith(inputLines->entry[i], "+++")) { type = NEW_FILE; useR = 1; padding = 4; lineNoL = -1; lineNoR = -1; startNewFileOk = FALSE; } else if (stringStartsWith(inputLines->entry[i], "@@")) { syncLineNumbers(inputLines->entry[i], &lineNoL, &lineNoR); if (firstInfoLine) { // Don't print the info row but still increment the line // numbers normally. // TODO: Might be better to mark the row as the first and // hide it with CSS instead of just not printing it. lineNoL++; lineNoR++; } else { type = INFO; useR = 1; useL = 1; padding = 1; } firstInfoLine = FALSE; } else if (bdata(inputLines->entry[i])[0] == '-') { type = OLD; useL = 1; } else if (bdata(inputLines->entry[i])[0] == '+') { type = NEW; useR = 1; } else if (bdata(inputLines->entry[i])[0] == ' ') { type = SHARED; useL = 1; useR = 1; } else { type = HEADER; lineNoL = 0; lineNoR = 0; firstInfoLine = TRUE; startNewFileOk = TRUE; startOldFileOk = TRUE; } // Balance. if (type == HEADER || (type == SHARED && (useL || useR)) || i == inputLines->qty - 1) { int difference = lineMapPosL - lineMapPosR; int j; if (difference > 0) { for (j = 0; j < difference; j++) { lineMapR[lineMapPosR].type = EMPTY; lineMapPosR++; } } else if (difference < 0) { for (j = 0; j < (difference * -1); j++) { lineMapL[lineMapPosL].type = EMPTY; lineMapPosL++; } } } if (useL) { lineMapL[lineMapPosL].inputPos = i; lineMapL[lineMapPosL].type = type; lineMapL[lineMapPosL].padding = padding; lineMapL[lineMapPosL].lineNo = lineNoL - 1; lineMapL[lineMapPosL].leadingSpaces = 0; lineMapPosL++; lineNoL++; } if (useR) { lineMapR[lineMapPosR].inputPos = i; lineMapR[lineMapPosR].type = type; lineMapR[lineMapPosR].padding = padding; lineMapR[lineMapPosR].lineNo = lineNoR - 1; lineMapR[lineMapPosR].leadingSpaces = 0; lineMapPosR++; lineNoR++; } } // Mapping complete. Quick sanity check that both L and R cols have the // same length. if (lineMapPosL != lineMapPosR) { return "Error displaying diff (generated columns not equal in length)."; } // Now we do the formatting work based on the map. for (i = 0; i < lineMapPosL; i++) { int * highlightMaskA = NULL; int * highlightMaskB = NULL; bstring contentL; bstring contentR; int leadingSpacesL = 0; int leadingSpacesR = 0; if (lineMapL[i].type != EMPTY) { contentL = getContentFromLine( inputLines->entry[lineMapL[i].inputPos], lineMapL[i].padding, &leadingSpacesL ); lineMapL[i].leadingSpaces = leadingSpacesL; } if (lineMapR[i].type != EMPTY) { contentR = getContentFromLine( inputLines->entry[lineMapR[i].inputPos], lineMapR[i].padding, &leadingSpacesR ); lineMapR[i].leadingSpaces = leadingSpacesR; } // Compare changed lines if (lineMapL[i].type == OLD && lineMapR[i].type == NEW) { lineMapL[i].type = CHANGE; lineMapR[i].type = CHANGE; determineLineHighlighting( contentL, contentR, &highlightMaskA, &highlightMaskB ); } // Format output bcatcstr(html, "<tr>\n"); if (lineMapL[i].type == EMPTY) { createEmptyLine(html); } else { createLine(LEFT, html, contentL, lineMapL[i], highlightMaskA); bdestroy(contentL); } if (lineMapR[i].type == EMPTY) { createEmptyLine(html); } else { createLine(RIGHT, html, contentR, lineMapR[i], highlightMaskB); bdestroy(contentR); } bcatcstr(html, "</tr>\n"); free(highlightMaskA); free(highlightMaskB); } bcatcstr(html, "</table>\n</body>\n</html>\n"); free(lineMapL); free(lineMapR); } bdestroy(stdinContents); bstrListDestroy(inputLines); char * result = bstr2cstr(html, '-'); bdestroy(html); return result; // Caller should free() }
static int turboFromOptArg(const Cpu &cpu, char *const arg) { const std::string convertedArg(arg); int turbo; if (cpu.hasPstate()) { if (Log::isDebug()) { std::cout << "[Debug] System has intel_pstate" << std::endl; } if (convertedArg.compare("0") == 0 || stringStartsWith("on", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Turbo On" << std::endl; } turbo = Values::PSTATE_TURBO; } else if (convertedArg.compare("1") == 0 || stringStartsWith("off", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Turbo Off" << std::endl; } turbo = Values::PSTATE_NO_TURBO; } else { if (Log::isDebug()) { std::cout << "[Debug] Turbo is insane" << std::endl; } turbo = Values::TURBO_INSANE; } } else { if (Log::isDebug()) { std::cout << "[Debug] System does not have " << "intel_pstate" << std::endl; } if (convertedArg.compare("0") == 0 || stringStartsWith("off", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Turbo Off" << std::endl; } turbo = Values::CPUFREQ_NO_TURBO; } else if (convertedArg.compare("1") == 0 || stringStartsWith("on", convertedArg)) { if (Log::isDebug()) { std::cout << "[Debug] Turbo On" << std::endl; } turbo = Values::CPUFREQ_TURBO; } else { if (Log::isDebug()) { std::cout << "[Debug] Turbo is insane" << std::endl; } turbo = Values::TURBO_INSANE; } } return turbo; }
void ReadVectorFile(char* s) { char buff[256]; WCHAR wcFileInfo[512]; char* token; FILE* F = fopen(s, "rb"); while (fgets(buff, 255, F)) if (stringStartsWith(buff, "<!DOCTYPE CurveSetXML")) { StringCchPrintf(wcFileInfo, 512, L"(INFO) : This seems to be a diffusion curves file.\n"); OutputDebugString(wcFileInfo); break; } fgets(buff, 255, F); token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "image_width=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_fWidth = atof(token); while (!stringStartsWith(token, "image_height=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_fHeight = atof(token); while (!stringStartsWith(token, "nb_curves=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_cNum = atof(token); StringCchPrintf(wcFileInfo, 512, L"(INFO) : %d curves found in file.\n", m_cNum); OutputDebugString(wcFileInfo); m_curve.resize(m_cNum); m_cSegNum = 0; D3DXVECTOR2 maxBound = D3DXVECTOR2(-1000000, -1000000); D3DXVECTOR2 minBound = D3DXVECTOR2(1000000, 1000000); for (int i1 = 0; i1 < m_cNum; i1++) { while (!stringStartsWith(buff, " <curve nb_control_points")) { fgets(buff, 255, F); } token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "nb_control_points=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].pNum = atof(token); m_cSegNum += ((m_curve[i1].pNum - 1) / 3); while (!stringStartsWith(token, "nb_left_colors=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].clNum = atof(token); while (!stringStartsWith(token, "nb_right_colors=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].crNum = atof(token); while (!stringStartsWith(token, "nb_blur_points=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].bNum = atof(token); // read in individual curve data m_curve[i1].p.resize(m_curve[i1].pNum); for (int i2 = 0; i2 < m_curve[i1].pNum; i2++) { while (!stringStartsWith(buff, " <control_point ")) { fgets(buff, 255, F); } token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "x=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].p[i2].y = atof(token); while (!stringStartsWith(token, "y=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].p[i2].x = atof(token); fgets(buff, 255, F); //extend the bounds if necessary if (m_curve[i1].p[i2].y < minBound.y) { minBound.y = m_curve[i1].p[i2].y; } if (m_curve[i1].p[i2].y > maxBound.y) { maxBound.y = m_curve[i1].p[i2].y; } if (m_curve[i1].p[i2].x < minBound.x) { minBound.x = m_curve[i1].p[i2].x; } if (m_curve[i1].p[i2].x > maxBound.x) { maxBound.x = m_curve[i1].p[i2].x; } } m_curve[i1].cl.resize(m_curve[i1].clNum); for (int i2 = 0; i2 < m_curve[i1].clNum; i2++) { while (!stringStartsWith(buff, " <left_color ")) { fgets(buff, 255, F); } token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "G=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cl[i2].col.y = atof(token) / 256.0; while (!stringStartsWith(token, "R=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cl[i2].col.z = atof(token) / 256.0; while (!stringStartsWith(token, "globalID=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cl[i2].off = atof(token); while (!stringStartsWith(token, "B=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cl[i2].col.x = atof(token) / 256.0; fgets(buff, 255, F); } m_curve[i1].cr.resize(m_curve[i1].crNum); for (int i2 = 0; i2 < m_curve[i1].crNum; i2++) { while (!stringStartsWith(buff, " <right_color ")) { fgets(buff, 255, F); } token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "G=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cr[i2].col.y = atof(token) / 256.0; while (!stringStartsWith(token, "R=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cr[i2].col.z = atof(token) / 256.0; while (!stringStartsWith(token, "globalID=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cr[i2].off = atof(token); while (!stringStartsWith(token, "B=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].cr[i2].col.x = atof(token) / 256.0; fgets(buff, 255, F); } m_curve[i1].b.resize(m_curve[i1].bNum); for (int i2 = 0; i2 < m_curve[i1].bNum; i2++) { while (!stringStartsWith(buff, " <best_scale")) { fgets(buff, 255, F); } token = strtok(buff, " \"\t"); while (!stringStartsWith(token, "value=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].b[i2].blurr = atof(token); while (!stringStartsWith(token, "globalID=")) { token = strtok(NULL, " \"\t"); } token = strtok(NULL, " \"\t"); m_curve[i1].b[i2].off = atof(token); fgets(buff, 255, F); } } fclose(F); //scale the whole image between -1 and 1 D3DXVECTOR2 middlePan = D3DXVECTOR2(0.5 * (maxBound.x + minBound.x), 0.5 * (maxBound.y + minBound.y)); for (int i1 = 0; i1 < m_cNum; i1++) for (int i2 = 0; i2 < m_curve[i1].pNum; i2++) { m_curve[i1].p[i2].x = 2.0f * (m_curve[i1].p[i2].x - middlePan.x) / m_fWidth; m_curve[i1].p[i2].y = 2.0f * (m_curve[i1].p[i2].y - middlePan.y) / m_fHeight; } StringCchPrintf(wcFileInfo, 512, L"(INFO) : %d curve segments found in file.\n", m_cSegNum); OutputDebugString(wcFileInfo); }