ObjectArx开发对txt文本文件的操作一例

admin

1. // MyArxFirst.cpp : 定义 DLL 应用程序的导出函数。
2. //ObjectArx开发对txt文本文件的操作一例
4. #include "stdafx.h"
5. #include <aced.h>
6. #include <rxregsvc.h>
7. #include <tchar.h>
9. #include <fstream>
10. #include <iostream>
11. //
12. #include <comdef.h>
15. using namespace std;
17. //定义两个函数
18. void initApp();
19. void unloadApp();
21. //定义命令函数
22. //------------------------------------------
23. //打印"Hello world!"在AutoCAD Command上  的命令
24. void hello();
26. //打印文件内容 的命令
27. void pfvalue();
29. //ado连接数据库的方法 的命令
30. void pdbvalue();
32. //定义一般函数
33. //------------------------------------------
34. ACHAR* ConvertCharPtrToAcharPtr(const char* src);
35. ACHAR* ConvertCharPtrToAcharPtr2(const char* src);
36. //
37. char* ConvertAcharPtrToCharPtr(const ACHAR* src);
38. char* ConvertAcharPtrToCharPtr2(const ACHAR* src);
39. //通用转换函数
40. 采用bstr采用t Get采用bstr采用t(char* src);
41. 采用bstr采用t Get采用bstr采用t采用W(wchar采用t* src);
42. char* GetCharPtr(采用bstr采用t bstrt);
43. wchar采用t* GetWchar采用t(采用bstr采用t bstrt);
45. //打印函数
46. void pfvalue采用default(const ACHAR* filepath);
48. //打印文件内容2 函数
49. void pfvalue2(const ACHAR* filepath);
51. //ado连接数据库的方法 函数
52. void pdbvalue(const ACHAR *filepath);
53. //------------------------------------------
55. extern "C"
56. AcRx::AppRetCode
57. acrxEntryPoint(AcRx::AppMsgCode msg, void* pkt)
58. //void acrxEntryPoint(void* pkt)
59. {
60.         switch (msg)
61.         {
62.                 case AcRx::kInitAppMsg:
63.                         acrxDynamicLinker->unlockApplication(pkt);
64.                         acrxRegisterAppMDIAware(pkt);
65.                         initApp();
66.                         break;
67.                 case AcRx::kUnloadAppMsg:
68.                         unloadApp();
69.                         break;
70.                 default:
71.                     break;
72.         }
73.         return AcRx::kRetOK;
74. }
78. void initApp()
79. {
80.     //register a command with the AutoCAD command mechanism
81.         //string macro 用法:
82.         //采用T("helloworld") or  采用采用T("helloworld")  or ACRX采用T("helloworld")
83.         acedRegCmds->addCommand(ACRX采用T("HELLOWORLD采用COMMANDS"),
84.                                     ACRX采用T("ArxHsgBag"),
85.                                                         ACRX采用T("Hello"),
86.                                                         ACRX采用CMD采用TRANSPARENT,
87.                                                         hello);
88.         acedRegCmds->addCommand(ACRX采用T("PFVALUE采用COMMANDS"),
89.                                     ACRX采用T("ArxHsgBag"),
90.                                                         ACRX采用T("pfvalue"),
91.                                                         ACRX采用CMD采用TRANSPARENT,
92.                                                         pfvalue);
93.         acedRegCmds->addCommand(ACRX采用T("PDBVALUE采用COMMANDS"),
94.                                     ACRX采用T("ArxHsgBag"),
95.                                                         ACRX采用T("pdbvalue"),
96.                                                         ACRX采用CMD采用TRANSPARENT,
97.                                                         pdbvalue);
98.         //
99. }
102. void unloadApp()
103. {
104.     acedRegCmds->removeGroup(ACRX采用T("HELLOWORLD采用COMMANDS"));
105.         acedRegCmds->removeGroup(ACRX采用T("PFVALUE采用COMMANDS"));
106.         acedRegCmds->removeGroup(ACRX采用T("PDBVALUE采用COMMANDS"));
107. }
110. //----------------------------------------------------
111. //hello命令
112. void hello()
113. {
114.     acutPrintf(ACRX采用T("\n第一个Arx程序Hello World!"));
115.        
116. }
117. //打印文件内容 命令
118. void pfvalue()
119. {       
120.         acutPrintf(采用T("开始输出文件内信息：\n"));
121.     const ACHAR* filepath=ACRX采用T("d:\\test.txt");  //OK
122.         acutPrintf(filepath);        //OK
123.         pfvalue采用default(filepath); //OK
124.         pfvalue2(filepath);  //OK
125. }
126. //输出数据库表内记录的命令
127. void pdbvalue()
128. {
129.     acutPrintf(采用T("开始输出数据库表内记录：\n"));
130.         //...
131. }
132. //----------------------------------------------------
133. ACHAR* ConvertCharPtrToAcharPtr(const char* src)
134. {
135.         ACHAR* tmp;
136.         采用bstr采用t AStr = src;       
137.     LPWSTR AstrW = LPTSTR(AStr);
138.     tmp=(ACHAR *)AstrW;
139.         return tmp;
140. }
141. ACHAR* ConvertCharPtrToAcharPtr2(const char* src)
142. {
143.         // Convert to a wchar采用t*
144.     size采用t srcsize = strlen(src) + 1;
145.     size采用t newsize = srcsize;       
146.     size采用t convertedChars = 0;
147.     wchar采用t *wcstring;
148.         wcstring=new wchar采用t[newsize];
149.     mbstowcs采用s(&convertedChars, wcstring, srcsize, src, 采用TRUNCATE);
150.     //wcscat采用s(wcstring, L" (wchar采用t *)");
151.     //wcout << wcstring << endl;
152.         return wcstring;
153. }
154. char* ConvertAcharPtrToCharPtr(const ACHAR* src)  //
155. {
156.     char* tmp;
157.         采用bstr采用t bstrt(src);
158.         tmp=GetCharPtr(bstrt);
159.         return tmp;
160. }
161. char* ConvertAcharPtrToCharPtr2(const ACHAR* src)
162. {
163.     // Convert to a char*
164.     size采用t srcsize = wcslen(src) + 1;   
165.         size采用t newsize = srcsize;
166.     size采用t convertedChars = 0;
167.     char *nstring;
168.         nstring=new char[newsize];
169.     wcstombs采用s(&convertedChars, nstring, srcsize, src, 采用TRUNCATE);   
170.         return nstring;
171. }
172. //
173. 采用bstr采用t Get采用bstr采用t(char* src)
174. {
175.      采用bstr采用t bstrt(src);
176.          return bstrt;
177. }
178. 采用bstr采用t Get采用bstr采用t采用W(wchar采用t* src)
179. {
180.     // Convert to a 采用bstr采用t
181.     采用bstr采用t bstrt(src);
182.     //bstrt += " (采用bstr采用t)";
183.     //cout << bstrt << endl;
184.         return bstrt;
185. }
186. char* GetCharPtr(采用bstr采用t bstrt)
187. {
188.     // Convert to a char*
189.     size采用t newsize = bstrt.length()+1;
190.     char *nstring;nstring=new char[newsize];
191.     strcpy采用s(nstring,newsize,(char *)bstrt);
192.     //strcat采用s(nstring, " (char *)");
193.     //cout << nstring << endl;
194.         return nstring;
195. }
196. wchar采用t* GetWchar采用t(采用bstr采用t bstrt)
197. {
198.     // Convert to a wchar采用t*
199.         int srcsize=bstrt.length()+1;
200.     wchar采用t *wcstring;wcstring=new wchar采用t[srcsize];
201.     wcscpy采用s(wcstring,srcsize,(wchar采用t *)bstrt);
202.     //wcscat采用s(wcstring, L" (wchar采用t *)");
203.     //wcout << wcstring << endl;
204.         return wcstring;
205. }
206. //CComBSTR GetCComBSTR(char* src)
207. //{
208. //    // Convert to a CComBSTR
209. //    CComBSTR ccombstr(src);
210. //    /*if (ccombstr.Append(L" (CComBSTR)") == S采用OK)
211. //    {
212. //        CW2A printstr(ccombstr);
213. //        cout << printstr << endl;
214. //    }*/
215. //        return ccombstr;
216. //}
217. //----------------------------------------------------
218. //打印文件内容1  C文件操作函数   OK
219. void pfvalue采用default(const ACHAR* filepath)
220. {
221.           acutPrintf(采用T("\n-----下面是c文件操作函数打开的内容-----\n"));          
222.           acutPrintf(filepath);acutPrintf(采用T("\n"));
223.       FILE *fp;
224.           int linesize=4000;
225.           char *line;line=new char[linesize];
226.           const char* path=ConvertAcharPtrToCharPtr(filepath);
227.           ACHAR* wtmp=ConvertCharPtrToAcharPtr(path);          
228.           acutPrintf(wtmp);acutPrintf(采用T("\n"));
229.           if((fp=fopen(path,"r"))==NULL)
230.           {
231.                   acutPrintf(采用T("\nfile cannot be opened\n"));                  
232.           }          
233.           else
234.           {
235.                   const ACHAR* tmp;
236.                   while(!feof(fp))
237.                   {
238.                           if(fgets(line,linesize,fp)!=NULL)
239.                           {
240.                                   tmp=ConvertCharPtrToAcharPtr(line);
241.                                   acutPrintf(tmp);
242.                           }
243.                   }
244.                   fclose(fp);
245.           }
246. }
248. //打印文件内容2  ifstream类      OK
249. void pfvalue2(const ACHAR* filepath)
250. {       
251.          //--file2 open
252.          //filepath="d:\\test.txt";
253.         acutPrintf(ACRX采用T("\n"));
254.         acutPrintf(filepath);
255.         ifstream r(filepath,ifstream.in);
256.          if(!r)
257.          {
258.                  acutPrintf(ACRX采用T("打开文件出错!"));
259.          }
260.          else
261.          {
262.                  const ACHAR* tmpAchar;
263.                  //char line[4000];   //[100]2000
264.                  int linesize=4000;
265.                  char* line;line=new char[linesize];
266.                  while(r>>line)
267.                  {                          
268.                           tmpAchar=ConvertCharPtrToAcharPtr(line);
269.                           acutPrintf(tmpAchar);
270.                           acutPrintf(ACRX采用T("\n"));
271.                  }
272.                  r.close();       
273.                  acutPrintf(ACRX采用T("输出文件内容完毕!"));
274.          }
275. }
278. //ObjectARX offers the following input functions.
279. //Refer to the ObjectARX Online Help for a complete description of
280. //how to use these functions.
281. //acedGetInt        used to get an integer value
282. //acedGetReal       used to get a real value
283. //acedGetString     used to get a string
284. //acedGetAngle      used to get a angle value
285. //acedGetKword      used to get a key word
286. //acedInitGet       used to initialize acedGetXXXX functions
287. //acedGetFileD      used to retrieve file selection from a file dialog
288. //acedGetPoint      used to pick a point
289. //acedGetDist       used to get the distance between two points
290. //acedGetCorner     see Online Help for a complete description
291. //
292. //ObjectARX offers the following functions for selection of AutoCAD entities.
293. //(Again refer to the ObjectARX Online Help for a complete description of
294. //how to use these functions).
295. //
296. //acedEntSel       used to select a single entity
297. //acedNEntSel      used to select a single, nested entity
298. //acedNEntSelP     used to select a single, nested entity
299. //acutSSGet        used to select multiple entities
301. //--the---end---

复制代码