[每日一码] 一个查询DWG文件属性的类

admin

1. //////////////////////////////////////////////////////////////////////////
2. // Реализация чтения DwgProps для AutoCAD 2004...2016 (возможно и дальше,
3. // если сохранится структура dwg-файла).
4. //////////////////////////////////////////////////////////////////////////
6. #include <io.h>
7. #include <sys/stat.h>
8. #include <fcntl.h>
9. #include <malloc.h>
10. #include <stdlib.h>
11. #include <vector>
12. #include <string>
13. //
14. // Имена стандартных свойств чертежа
15. //
16. const char *stdPropNames[] = {
17.         "title",
18.         "subject",
19.         "author",
20.         "keywords",
21.         "comments",
22.         "lastSavedBy",
23.         "revisionNumber",
24.         "hyperlinkBase"
25. };
27. class DwgProps
28. {
29.         struct record {
30.                 WORD len;
31.                 union {
32.                         char    c[32767];
33.                         wchar采用t w[32767];
34.                 };
35.         };
37. public:
39.         DwgProps() {
40.                 for (int i=0; i < sizeof(stdPropNames)/sizeof(stdPropNames[0]); i++)  {
41.                         m采用stdProps.push采用back("");
42.                 }
43.                 memset(bTotalEditingTime,0,sizeof(bTotalEditingTime));
44.                 memset(bCreateDateTime,0,sizeof(bCreateDateTime));
45.                 memset(bModifiedDateTime,0,sizeof(bModifiedDateTime));
46.         };
47.         ~DwgProps() {}
49.         //  data items
50.         const char *title()          const    {return m采用stdProps[0].c采用str(); }
51.         const char *subject()        const    {return m采用stdProps[1].c采用str(); }
52.         const char *author()         const    {return m采用stdProps[2].c采用str(); }
53.         const char *keywords()       const    {return m采用stdProps[3].c采用str(); }
54.         const char *comments()       const    {return m采用stdProps[4].c采用str(); }
55.         const char *lastSavedBy()    const    {return m采用stdProps[5].c采用str(); }
56.         const char *revisionNumber() const    {return m采用stdProps[6].c采用str(); }
57.         const char *hyperlinkBase()  const    {return m采用stdProps[7].c采用str(); }
58.         const char *customName(int idx) const  {
59.                 return ((idx >= 0 && idx < (int)m采用custPropNames.size())?m采用custPropNames[idx].c采用str():0);
60.         }
61.         const char *customValue(int idx) const {
62.                 return ((idx >= 0 && idx < (int)m采用custPropValues.size())?m采用custPropValues[idx].c采用str():0);
63.         }
64.         const char *customValue(const char *name) const  {
65.                 for (int i=0; i < (int)m采用custPropNames.size(); i++) {
66.                         if (m采用custPropNames[i] == name) return m采用custPropValues[i].c采用str();
67.                 }
68.                 return 0;
69.         }
71.         int    customNumber() const { return (int) m采用custPropNames.size(); }
72.         ULONG      inDwg()   { return ReadDiffDate(bTotalEditingTime); }
73.         SYSTEMTIME created() { return ReadDate(bCreateDateTime); }
74.         SYSTEMTIME updated() { return ReadDate(bModifiedDateTime); }
76.         const void DateToString(char *buf, SYSTEMTIME tm)
77.         {
78.                 sprintf( buf,
79.                         "%d-%02d-%02d %02d:%02d:%02d.%03d",
80.                         tm.wYear, tm.wMonth, tm.wDay,
81.                         tm.wHour, tm.wMinute, tm.wSecond, tm.wMilliseconds);
82.         }
84.         const void DiffDateToString(char *buf, ULONG tDiff)
85.         {
86.                 int days = tDiff / (24*60*60*1000);
87.                 tDiff -= days * (24*60*60*1000);
88.                 int hours = tDiff / (60*60*1000);
89.                 tDiff -= hours * (60*60*1000);
90.                 int minutes = tDiff / (60*1000);
91.                 tDiff -= minutes * (60*1000);
92.                 int seconds = tDiff / 1000;
93.                 tDiff -= seconds * (1000);
94.                 int mseconds = tDiff;
95.                 sprintf( buf,
96.                         "Days:%d Hours:%d Minutes:%d Seconds:%d Milliseconds:%d",
97.                         days, hours, minutes, seconds, mseconds);
98.         }
99.         int load(const char * fname)
100.         {
101.                 bool unicode = false;
102.                 int h;
103.                 char buf[32767]; memset(buf,0,sizeof(buf));
104.                 if ((h = 采用open(fname,采用O采用BINARY|采用O采用RDONLY)) == -1)
105.                         return 0;
106.                 char ACADVER[7];
107.                 if (采用read(h,ACADVER,sizeof(ACADVER)) <= 0) {
108.                         采用close(h); return 0;
109.                 }
110.                 if (atoi(ACADVER+2) < 1018) {  // AutoCAD R14,2000...2002 обрабатывать не будем
111.                         采用close(h); return 0;
112.                 }
113.                 if (atoi(ACADVER+2) >= 1021) { // AutoCAD 2007... строки в Unicode
114.                         unicode = true;
115.                 }
117.                 // Указатель перемещаем на WORD, содержащий смещение DwgProps
118.                 if (采用lseek(h,0x20,SEEK采用SET) == -1) {
119.                         采用close(h); return 0;
120.                 }
121.                 // Считываем смещение DwgProps
122.                 WORD offset采用dwgprops = 0;
123.                 if (采用read(h,&offset采用dwgprops,sizeof(offset采用dwgprops)) <= 0) {
124.                         采用close(h); return 0;
125.                 }
126.                 long begin采用offset = offset采用dwgprops, cur采用offset = offset采用dwgprops;
127.                 // Устанавливаем указатель на начало DwgProps
128.                 if (采用lseek(h,offset采用dwgprops,SEEK采用SET) == -1) {
129.                         采用close(h); return 0;
130.                 }
131.                 // Теперь можно читать длины и сами строки:
132.                 record rec;
133.                 for (int i=0; i < sizeof(stdPropNames)/sizeof(stdPropNames[0]); i++) {
134.                         if (采用read(h,&rec,sizeof(record)) == -1) {
135.                                 采用close(h); return 0;
136.                         }
137.                         if (unicode) {
138.                                 WideCharToMultiByte(CP采用ACP,0,rec.w,rec.len,buf,rec.len,0,NULL);
139.                                 m采用stdProps[i] = buf;
140.                         } else {
141.                                 m采用stdProps[i] = rec.c;
142.                         }
143.                         cur采用offset += (rec.len*((unicode)?2:1) + sizeof(rec.len));
144.                         if (采用lseek(h,cur采用offset,SEEK采用SET) == -1) {
145.                                 采用close(h); return 0;
146.                         }
147.                 }
148.                 if (采用read(h,&bTotalEditingTime,sizeof(bTotalEditingTime)) == -1) {
149.                         采用close(h); return 0;
150.                 }
151.                 if (采用read(h,&bCreateDateTime,sizeof(bCreateDateTime)) == -1) {
152.                         采用close(h); return 0;
153.                 }
154.                 if (采用read(h,&bModifiedDateTime,sizeof(bModifiedDateTime)) == -1) {
155.                         采用close(h); return 0;
156.                 }
158.                 cur采用offset += (sizeof(bTotalEditingTime)+ sizeof(bCreateDateTime) + sizeof(bModifiedDateTime));
160.                 if (采用lseek(h,cur采用offset,SEEK采用SET) == -1) {
161.                         采用close(h); return 0;
162.                 }
164.                 // Читаем количество собственных (custom) переменных
166.                 WORD nCust = 0;
168.                 if (采用read(h,&nCust,sizeof(nCust)) <= 0) { 采用close(h); return 0; }
170.                 cur采用offset += sizeof(WORD);
172.                 for (int i=0; i < nCust; i++) {
173.                         // Считываем имя переменной
174.                         if (采用read(h,&rec,sizeof(record)) == -1) {采用close(h); return 0;}
175.                         if (unicode) {
176.                                 WideCharToMultiByte(CP采用ACP,0,rec.w,rec.len,buf,rec.len,0,NULL);
177.                                 m采用custPropNames.push采用back(buf);
178.                         } else {
179.                                 m采用custPropNames.push采用back(rec.c);
180.                         }
182.                         cur采用offset += (rec.len*((unicode)?2:1) + sizeof(rec.len));
184.                         if (采用lseek(h,cur采用offset,SEEK采用SET) == -1) {
185.                                 采用close(h); return 0;
186.                         }
187.                         if (采用read(h,&rec,sizeof(record)) == -1) {采用close(h); return 0;}
188.                         if (unicode) {
189.                                 WideCharToMultiByte(CP采用ACP,0,rec.w,rec.len,buf,rec.len,0,NULL);
190.                                 m采用custPropValues.push采用back(buf);
191.                         } else {
192.                                 m采用custPropValues.push采用back(rec.c);
193.                         }
195.                         cur采用offset += (rec.len*((unicode)?2:1) + sizeof(rec.len));
196.                         if (采用lseek(h,cur采用offset,SEEK采用SET) == -1) {采用close(h); return 0;}
197.                 }
198.                 采用close(h);
199.                 return 1;
200.         }
202. private:
203.         //  data
204.         std::vector<std::string> m采用stdProps;
205.         std::vector<std::string> m采用custPropNames;
206.         std::vector<std::string> m采用custPropValues;
207.         byte bTotalEditingTime[8];
208.         byte bCreateDateTime[8];
209.         byte bModifiedDateTime[8];
210.         SYSTEMTIME minDate, maxDate;
211.         //
212.         // Преобразование даты/времени из юлианского календаря
213.         //
214.         SYSTEMTIME FromJulian(ULONG days)
215.         {
216.                 FILETIME fmin = {0, 0} , fmax = {0x7fffffff, 0xffffffff} ;
217.                 FileTimeToSystemTime(&fmin, &minDate);  FileTimeToSystemTime(&fmax, &maxDate);
218.                 SYSTEMTIME s; memset(&s,0,sizeof(s));
219.                 if (days < 0x1a4452) return minDate;
220.                 if (days > 0x51fe2c) return maxDate;
221.                 int j = days + 32044;
222.                 int g = j / 146097;
223.                 int dg = j % 146097;
224.                 int c = (((dg / 36524) + 1) * 3) / 4;
225.                 int dc = dg - (c * 36524);
226.                 int b = dc / 1461;
227.                 int db = dc % 1461;
228.                 int a = (((db / 365) + 1) * 3) / 4;
229.                 int da = db - (a * 365);
230.                 int y = (((g * 400) + (c * 100)) + (b * 4)) + a;
231.                 int m = (((da * 5) + 308) / 153) - 2;
232.                 int d = (da - (((m + 4) * 153) / 5)) + 0x7a;
233.                 int year = (y - 4800) + ((m + 2) / 12);
234.                 int month = ((m + 2) % 12) + 1;
235.                 int day = d + 1;
236.                 s.wYear = year;
237.                 s.wMonth = month;
238.                 s.wDay = day;
239.                 s.wHour = 2;
240.                 s.wMinute = 0;
241.                 s.wSecond = 0;
242.                 s.wDayOfWeek = 0;
243.                 s.wMilliseconds = 0;
244.                 return s;
245.         }
246.         //
247.         // Добавление дробной части (миллисекунд)
248.         //
249.         SYSTEMTIME addMilliSecs(SYSTEMTIME s, double mseconds) {
250.                 FILETIME f; SystemTimeToFileTime(&s, &f);
251.                 ULARGE采用INTEGER u;
252.                 memcpy(&u, &f, sizeof(u));
253.                 ULONGLONG mmsec = mseconds * 10000;
254.                 u.QuadPart += mmsec;
255.                 memcpy(&f, &u, sizeof(f));
256.                 FileTimeToSystemTime(&f, &s);
257.                 return s;
258.         }
259.         //
260.         // Чтение даты/времени
261.         //
262.         const SYSTEMTIME ReadDate(byte *src)
263.         {
264.                 ULONG days = *((ULONG *)(src)); src += 4;
265.                 ULONG fraction = *((ULONG *)(src)); src += 4;
266.                 SYSTEMTIME tm = FromJulian(days);
267.                 if (tm.wYear == maxDate.wYear)
268.                         return tm;
269.                 return addMilliSecs(tm,fraction);
270.         }
271.         //
272.         // Чтение интервала редактирования
273.         //
274.         const ULONG ReadDiffDate(byte* src)
275.         {
276.                 ULONG days = *((ULONG *)(src)); src += 4;
277.                 ULONG fraction = *((ULONG *)(src)); src += 4;
278.                 ULONG diff = days * 24 * 60 * 60 * 1000 + fraction;
279.                 return diff;
280.         }
283. };
284. ////-----------------------------------------
285. //// Пример использования класса DwgProps
286. ////-----------------------------------------
287. //#include "stdafx.h"
288. //#include <conio.h>
289. //#include <stdio.h>
290. //#include <string.h>
291. //#include <wtypes.h>
292. //#include <time.h>
293. //#include "DwgProps.h"
294. //
295. //
296. //const char * valid(const char *s)
297. //{
298. //  return s ? s : "";
299. //}
300. //
301. //void main(int argc, char *argv[])
302. //{
303. //  DwgProps p;
304. //
305. //  if ( argc < 2 )
306. //  {
307. //    fprintf(stderr, "Usage: dwgprops file [file ...]\n");
308. //    return;
309. //  }
310. //
311. //  //  loop over files
312. //  for ( int f = 1; f < argc; f++ )
313. //  {
314. //    printf("%s\n", argv[f]);
315. //
316. //    if ( p.load(argv[f]) )
317. //    {
318. //      //  print list of tags
319. //      printf("  Title:         [%s]\n", valid(p.title()));
320. //      printf("  Subject:       [%s]\n", valid(p.subject()));
321. //      printf("  Author:        [%s]\n", valid(p.author()));
322. //      printf("  Comments:      [%s]\n", valid(p.comments()));
323. //      printf("  Keywords:      [%s]\n", valid(p.keywords()));
324. //      printf("  HyperlinkBase: [%s]\n", valid(p.hyperlinkBase()));
325. //      printf("  LastSavedBy:   [%s]\n", valid(p.lastSavedBy()));
326. //      printf("  RevisionNo.:   [%s]\n", valid(p.revisionNumber()));
327. //      char buffer[ 256 ];
328. //      p.DiffDateToString(buffer, p.inDwg());
329. //      printf("  Edit time: %s\n", buffer);
330. //      p.DateToString(buffer, p.created());
331. //      printf("  Created:       [%s]\n", buffer);
332. //      p.DateToString(buffer, p.updated());
333. //      printf("  Updated:       [%s]\n", buffer);
334. //      for ( int i = 0; i < p.customNumber(); i++ ) {
335. //        printf("  Custom Name[%d]:   [%s]\n", i, valid(p.customName(i)));
336. //        printf("  Custom Value[%d]:  [%s]\n", i, valid(p.customValue(i)));
337. //      }
338. //    }
339. //  }
340. //}

复制代码