API tools faq
paste
Guest User

Untitled

a guest
Feb 20th, 2018
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.60 KB | None | 0 0
raw download clone embed print report
  1. #include "CVar.h"
  2.  
  3. void CVar::Init()
  4. {
  5. memset(&sValue,0,sizeof(sValue));
  6. memset(&uLimit,0,sizeof(uLimit));
  7. memset(&uCallback,0,sizeof(uCallback));
  8. memset(&sDefault,0,sizeof(sDefault));
  9. eType = FReal;
  10. lpszVarName = 0;
  11. lpszVarDescription = 0;
  12. dwVarFlags = 0;
  13. uLimit.String.nMaxLength = 0;
  14. bUseLimits = false;
  15. bCreated = false;
  16. }
  17.  
  18. CVar::CVar()
  19. {
  20. Init();
  21. }
  22. CVar::CVar(char* lpszName, char* lpszDescription, double dMinValue, double dMaxValue, double dDefaultValue, DWORD dwFlags, bool(*lpfnRealCallback)(double dPrevValue, double dCurrValue))
  23. {
  24. Init();
  25. Create(lpszName,lpszDescription,dMinValue,dMaxValue,dDefaultValue,dwFlags,lpfnRealCallback);
  26. }
  27. CVar::CVar(char* lpszName, char* lpszDescription, int nMinLength, int nMaxLength, char* lpszDefaultValue, DWORD dwFlags, bool(*lpfnStringCallback)(const char* lpszPrevValue, const char* lpszCurrValue))
  28. {
  29. Init();
  30. Create(lpszName,lpszDescription,nMinLength,nMaxLength,lpszDefaultValue,dwFlags,lpfnStringCallback);
  31. }
  32. CVar::~CVar()
  33. {
  34. if(bCreated) delete[] sValue.lpszValue;
  35. }
  36.  
  37. bool CVar::Create(char* lpszName, char* lpszDescription, double dMinValue, double dMaxValue, double dDefaultValue, DWORD dwFlags, bool(*lpfnRealCallback)(double dPrevValue, double dCurrValue))
  38. {
  39. if(bCreated) return(false);
  40. if(lpszName==0) return(false);
  41. (dMinValue==dMaxValue)?(bUseLimits = false):(bUseLimits = true);
  42.  
  43. sValue.lpszValue = new char[32];
  44. sDefault.dValue = dDefaultValue;
  45. uLimit.Real.dMinValue = dMinValue;
  46. uLimit.Real.dMaxValue = dMaxValue;
  47. eType = FReal;
  48. lpszVarName = lpszName;
  49. lpszVarDescription = lpszDescription;
  50. dwVarFlags = dwFlags;
  51. uCallback.lpfnRealCallback = lpfnRealCallback;
  52.  
  53. Reset();
  54.  
  55. bCreated = true;
  56.  
  57. return(true);
  58. }
  59. bool CVar::Create(char* lpszName, char* lpszDescription, int nMinLength, int nMaxLength, char* lpszDefaultValue, DWORD dwFlags, bool(*lpfnStringCallback)(const char* lpszPrevValue, const char* lpszCurrValue))
  60. {
  61. if(bCreated) return(false);
  62. if(lpszName==0) return(false);
  63. if(nMaxLength<1) return(false);
  64.  
  65. bUseLimits = true;
  66. sValue.lpszValue = new char[nMaxLength+1];
  67. sDefault.lpszValue = lpszDefaultValue;
  68. uLimit.String.nMinLength = nMinLength;
  69. uLimit.String.nMaxLength = nMaxLength;
  70. eType = FString;
  71. lpszVarName = lpszName;
  72. lpszVarDescription = lpszDescription;
  73. dwVarFlags = dwFlags;
  74. uCallback.lpfnStringCallback = lpfnStringCallback;
  75.  
  76. Reset();
  77.  
  78. bCreated = true;
  79.  
  80. return(true);
  81. }
  82.  
  83. bool CVar::Set(bool bValue)
  84. {
  85. if(!bCreated)return(false);
  86. switch(eType)
  87. {
  88. case FReal:
  89. {
  90. if(bUseLimits)
  91. {
  92. if(1>uLimit.Real.dMaxValue || 0<uLimit.Real.dMinValue) return(false);
  93. }
  94. if(bValue)
  95. {
  96. if(sValue.dValue == 1.0) return(true);
  97. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,1.0):true)
  98. {
  99. sValue.dValue = 1.0;
  100. return(true);
  101. }
  102. else
  103. {
  104. return(false);
  105. }
  106. }
  107. else
  108. {
  109. if(sValue.dValue == 0.0) return(true);
  110. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,0.0):true)
  111. {
  112. sValue.dValue = 0.0;
  113. return(true);
  114. }
  115. else
  116. {
  117. return(false);
  118. }
  119. }
  120. }
  121. case FString:
  122. {
  123. if(4<uLimit.String.nMinLength) return(false);
  124. if(bValue)
  125. {
  126. if(!strcmp(sValue.lpszValue,"true")) return(true);
  127. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback((const char*)sValue.lpszValue,"true"):true)
  128. {
  129. strncpy(sValue.lpszValue,"true",uLimit.String.nMaxLength);
  130. sValue.lpszValue[uLimit.String.nMaxLength-1] = 0;
  131. return(true);
  132. }
  133. else
  134. {
  135. return(false);
  136. }
  137. }
  138. else
  139. {
  140. if(!strcmp(sValue.lpszValue,"false")) return(true);
  141. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback((const char*)sValue.lpszValue,"false"):true)
  142. {
  143. strncpy(sValue.lpszValue,"false",uLimit.String.nMaxLength);
  144. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  145. return(true);
  146. }
  147. else
  148. {
  149. return(false);
  150. }
  151. }
  152. }
  153. default: return(false);
  154. }
  155. }
  156. bool CVar::Set(int nValue)
  157. {
  158. if(!bCreated)return(false);
  159. switch(eType)
  160. {
  161. case FReal:
  162. {
  163. if(bUseLimits)
  164. {
  165. if(nValue>uLimit.Real.dMaxValue) nValue=(int)uLimit.Real.dMaxValue;
  166. if(nValue<uLimit.Real.dMinValue) nValue=(int)uLimit.Real.dMinValue;
  167. }
  168. if(sValue.dValue == (double)nValue) return(true);
  169. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,(double)nValue):true)
  170. {
  171. sValue.dValue = (double)nValue;
  172. return(true);
  173. }
  174. else
  175. {
  176. return(false);
  177. }
  178. }
  179. case FString:
  180. {
  181. char cBuffer[16];
  182. _itoa(nValue,cBuffer,10);
  183.  
  184. if(uLimit.String.nMinLength>(int)strlen(cBuffer)) return(false);
  185.  
  186. if(!strcmp(cBuffer,sValue.lpszValue)) return(true);
  187. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback(sValue.lpszValue,cBuffer):true)
  188. {
  189. strncpy(sValue.lpszValue,cBuffer,uLimit.String.nMaxLength);
  190. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  191. return(true);
  192. }
  193. else
  194. {
  195. return(false);
  196. }
  197. return(true);
  198. }
  199. default: return(false);
  200. }
  201. }
  202. bool CVar::Set(float fValue)
  203. {
  204. if(!bCreated)return(false);
  205. switch(eType)
  206. {
  207. case FReal:
  208. {
  209. if(bUseLimits)
  210. {
  211. if(fValue>uLimit.Real.dMaxValue) fValue=(float)uLimit.Real.dMaxValue;
  212. if(fValue<uLimit.Real.dMinValue) fValue=(float)uLimit.Real.dMinValue;
  213. }
  214. if(sValue.dValue == (double)fValue) return(true);
  215. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,(double)fValue):true)
  216. {
  217. sValue.dValue = (double)fValue;
  218. return(true);
  219. }
  220. else
  221. {
  222. return(false);
  223. }
  224. }
  225. case FString:
  226. {
  227. char cBuffer[32];
  228. _snprintf(cBuffer,31,"%f",fValue);
  229. cBuffer[31] = 0;
  230.  
  231. if(uLimit.String.nMinLength>(int)strlen(cBuffer)) return(false);
  232. if(!strcmp(cBuffer,sValue.lpszValue)) return(true);
  233. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback(sValue.lpszValue,cBuffer):true)
  234. {
  235. strncpy(sValue.lpszValue,cBuffer,uLimit.String.nMaxLength);
  236. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  237. return(true);
  238. }
  239. else
  240. {
  241. return(false);
  242. }
  243. }
  244. default: return(false);
  245. }
  246. }
  247. bool CVar::Set(double dValue)
  248. {
  249. if(!bCreated)return(false);
  250. switch(eType)
  251. {
  252. case FReal:
  253. {
  254. if(sValue.dValue == dValue) return(true);
  255. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,dValue):true)
  256. {
  257. sValue.dValue = dValue;
  258. return(true);
  259. }
  260. else
  261. {
  262. return(false);
  263. }
  264. }
  265. case FString:
  266. {
  267. char cBuffer[32];
  268. _snprintf(cBuffer,31,"%f",dValue);
  269. cBuffer[31] = 0;
  270.  
  271. if(uLimit.String.nMinLength>(int)strlen(cBuffer)) return(false);
  272. if(!strcmp(cBuffer,sValue.lpszValue)) return(true);
  273. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback(sValue.lpszValue,cBuffer):true)
  274. {
  275. strncpy(sValue.lpszValue,cBuffer,uLimit.String.nMaxLength);
  276. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  277. return(true);
  278. }
  279. else
  280. {
  281. return(false);
  282. }
  283. }
  284. default: return(false);
  285. }
  286. }
  287. bool CVar::Set(char* lpszValue)
  288. {
  289. if(!bCreated)return(false);
  290. switch(eType)
  291. {
  292. case FReal:
  293. {
  294. double dNewValue = atof(lpszValue);
  295.  
  296. if(bUseLimits)
  297. {
  298. if(dNewValue>uLimit.Real.dMaxValue) dNewValue=uLimit.Real.dMaxValue;
  299. if(dNewValue<uLimit.Real.dMinValue) dNewValue=uLimit.Real.dMinValue;
  300. }
  301.  
  302. if(sValue.dValue == dNewValue) return(true);
  303. if(uCallback.lpfnRealCallback?uCallback.lpfnRealCallback(sValue.dValue,dNewValue):true)
  304. {
  305. sValue.dValue = dNewValue;
  306. return(true);
  307. }
  308. else
  309. {
  310. return(false);
  311. }
  312. }
  313. case FString:
  314. {
  315. if(uLimit.String.nMinLength>(int)strlen(lpszValue)) return(false);
  316. if(!strcmp(sValue.lpszValue,lpszValue)) return(true);
  317. if(uCallback.lpfnStringCallback?uCallback.lpfnStringCallback(sValue.lpszValue,lpszValue):true)
  318. {
  319. strncpy(sValue.lpszValue,lpszValue,uLimit.String.nMaxLength);
  320. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  321. return(true);
  322. }
  323. else
  324. {
  325. return(false);
  326. }
  327. }
  328. default: return(false);
  329. }
  330. }
  331.  
  332. bool CVar::GetBool()
  333. {
  334. if(!bCreated)return(false);
  335. switch(eType)
  336. {
  337. case FReal: if(sValue.dValue) return(true); else return(false);
  338. case FString: if(strcmp(sValue.lpszValue,"false")) return(true); else return(false);
  339. }
  340. return(false);
  341. }
  342. int CVar::GetInt()
  343. {
  344. if(!bCreated)return(0);
  345. switch(eType)
  346. {
  347. case FReal: return((int)(sValue.dValue));
  348. case FString: return((int)(atof((const char*)sValue.lpszValue)));
  349. }
  350. return(0);
  351. }
  352. float CVar::GetFloat()
  353. {
  354. if(!bCreated)return(0.0f);
  355. switch(eType)
  356. {
  357. case FReal: return((float)(sValue.dValue));
  358. case FString: return((float)(atof((const char*)sValue.lpszValue)));
  359. }
  360. return(0);
  361. }
  362. double CVar::GetDouble()
  363. {
  364. if(!bCreated)return(0.0);
  365. switch(eType)
  366. {
  367. case FReal: return(sValue.dValue);
  368. case FString: return(atof((const char*)sValue.lpszValue));
  369. }
  370. return(0);
  371. }
  372. const char* CVar::GetString()
  373. {
  374. if(!bCreated)return(false);
  375.  
  376. switch(eType)
  377. {
  378. case FReal:
  379. {
  380. _snprintf(sValue.lpszValue,31,"%f",sValue.dValue);
  381. sValue.lpszValue[31] = 0;
  382. return(sValue.lpszValue);
  383. }
  384. case FString: return(sValue.lpszValue);
  385. }
  386. return(0);
  387. }
  388.  
  389. bool CVar::Reset()
  390. {
  391. switch(eType)
  392. {
  393. case FReal:
  394. {
  395. double dValue = sDefault.dValue;
  396. if(bUseLimits)
  397. {
  398. if(dValue>uLimit.Real.dMaxValue) dValue=uLimit.Real.dMaxValue;
  399. if(dValue<uLimit.Real.dMinValue) dValue=uLimit.Real.dMinValue;
  400. }
  401. sValue.dValue = dValue;
  402. return(true);
  403. }
  404. case FString:
  405. {
  406. strncpy(sValue.lpszValue,sDefault.lpszValue,uLimit.String.nMaxLength);
  407. sValue.lpszValue[uLimit.String.nMaxLength] = 0;
  408. return(true);
  409. }
  410. }
  411. return(false);
  412. }
  413.  
  414. void CVar::operator=(bool bNew)
  415. {
  416. Set(bNew);
  417. }
  418. void CVar::operator=(int nNew)
  419. {
  420. Set(nNew);
  421. }
  422. void CVar::operator=(float fNew)
  423. {
  424. Set(fNew);
  425. }
  426. void CVar::operator=(double dNew)
  427. {
  428. Set(dNew);
  429. }
  430. void CVar::operator=(char* lpszNew)
  431. {
  432. Set(lpszNew);
  433. }
  434.  
  435. bool CVar::operator==(bool bValue)
  436. {
  437. if(GetBool() == bValue) return(true);
  438. else return(false);
  439. }
  440. bool CVar::operator==(int nValue)
  441. {
  442. if(GetInt() == nValue) return(true);
  443. else return(false);
  444. }
  445. bool CVar::operator==(float fValue)
  446. {
  447. if(GetFloat() == fValue) return(true);
  448. else return(false);
  449. }
  450. bool CVar::operator==(double dValue)
  451. {
  452. if(GetDouble() == dValue) return(true);
  453. else return(false);
  454. }
  455. bool CVar::operator==(char* lpszValue)
  456. {
  457. if(!strcmp(GetString(),lpszValue)) return(true);
  458. else return(false);
  459. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!