← Back to branch summary

~librecad-dev/librecad/librecad

« back to all changes in this revision

Viewing changes to libraries/jwwlib/src/jwwdoc.h

  • Committer: Scott Howard
  • Date: 2014-02-21 19:07:55 UTC
  • Revision ID: showard@debian.org-20140221190755-csjax9wb146hgdq4
first commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
libraries/jwwlib/src/jwwdoc.h
 
1
#ifndef JWWDOC_H
 
2
#define JWWDOC_H
 
3
 
 
4
#include "jwtype.h"
 
5
/*
 
6
#include <iomanip>
 
7
#include <iostream>
 
8
#include <fstream>
 
9
#include <string>
 
10
#include <algorithm>
 
11
#include <vector>
 
12
#include <list>
 
13
#include <iterator>
 
14
 
 
15
typedef double  DOUBLE;
 
16
typedef unsigned long DWORD, *LPDWORD;
 
17
typedef unsigned short WORD, *LPWORD;
 
18
typedef unsigned char BYTE, *LPBYTE;
 
19
//typedef       bool    BOOL;
 
20
using namespace std;
 
21
*/
 
22
typedef struct  _DPoint{
 
23
        DOUBLE  x;
 
24
        DOUBLE  y;
 
25
}DPoint;
 
26
 
 
27
//属性要素定義
 
28
typedef struct  _JWWLay{
 
29
        DWORD   m_aanLay;
 
30
        DWORD   m_aanLayProtect;
 
31
}JWWLay;
 
32
 
 
33
typedef struct  _JWWGLay{
 
34
        DWORD   m_anGLay;
 
35
        DWORD   m_anWriteLay;
 
36
        DOUBLE  m_adScale;
 
37
        DWORD   m_anGLayProtect;
 
38
        _JWWLay m_nLay[16];
 
39
}JWWGLay;
 
40
 
 
41
typedef struct  _JWWZoom{
 
42
        DOUBLE m_dZoomJumpBairitsu;
 
43
        DPoint m_DPZoomJumpGenten;
 
44
        DWORD m_nZoomJumpGLay;
 
45
}JWWZoom;
 
46
 
 
47
typedef struct  _JWWPen{
 
48
        DWORD m_m_aPenColor;
 
49
        DWORD m_anPenWidth;
 
50
}JWWPen;
 
51
 
 
52
typedef struct  {
 
53
        DWORD m_aPrtpenColor;
 
54
        DWORD m_anPrtPenWidth;
 
55
        DOUBLE m_adPrtTenHankei;
 
56
}JWWPrtPen;
 
57
 
 
58
typedef struct  JWWLType1{
 
59
        DWORD m_alLtype;
 
60
        DWORD m_anTokushusSenUnitDot;
 
61
        DWORD m_anTokushuSenPich;
 
62
        DWORD m_anPrtTokushuSenPich;
 
63
}JWWLType1;
 
64
 
 
65
typedef struct  _JWWLType2{
 
66
        DWORD m_alLtype;
 
67
        DWORD m_anRandSenWide;
 
68
        DWORD m_anTokushuSenPich;
 
69
        DWORD m_anPrtRandSenWide;
 
70
        DWORD m_anPrtTokushuSenPich;
 
71
}JWWLType2;
 
72
 
 
73
typedef struct  _JWWLType3{
 
74
        DWORD m_alLtype;
 
75
        DWORD m_anTokushusSenUnitDot;
 
76
        DWORD m_anTokushuSenPich;
 
77
        DWORD m_anPrtTokushuSenPich;
 
78
}JWWLType3;
 
79
 
 
80
typedef struct  _JWWaMoji{
 
81
        double m_adMojiX;
 
82
        double m_adMojiY;
 
83
        double m_adMojiD;
 
84
        DWORD m_anMojiCol;
 
85
}JWWaMoji;
 
86
 
 
87
#define SXCOL_EXT       100
 
88
typedef struct _SXFCOL {
 
89
        //画面出力色
 
90
        DWORD   m_aPenColor[357];
 
91
    DWORD       m_anPenWidth[357];
 
92
    //プリンタ出力色
 
93
    string      m_astrUDColorName[257];
 
94
        DWORD   m_aPrtPenColor[357];
 
95
        DWORD   m_anPrtPenWidth[357];
 
96
        DOUBLE  m_adPrtTenHankei[357];
 
97
}SXFCOL;
 
98
 
 
99
#define SXLTP_EXT       30
 
100
typedef struct  _SXFLTP {
 
101
        DWORD   m_alLType[63];
 
102
        DWORD   m_anTokushuSenUintDot[63];
 
103
        DWORD   m_anTokushuSenPich[63];
 
104
        DWORD   m_anPrtTokushuSenPich[63];
 
105
        string  m_astrUDLTypeName[33];                
 
106
        DWORD   m_anUDLTypeSegment[33];  
 
107
        DOUBLE  m_aadUDLTypePitch[33][11]; 
 
108
}SXFLTP;
 
109
 
 
110
//
 
111
// ヘッダー部
 
112
//
 
113
class   JWWHead
 
114
{
 
115
public:
 
116
        string head;    //JWWのデータファイルの宣言
 
117
        DWORD JW_DATA_VERSION;  //バージョンNo.
 
118
        string m_strMemo;       //ファイルメモ
 
119
        DWORD m_nZumen; //図面サイズ
 
120
        DWORD m_nWriteGLay;     //レイヤグループ・レイヤ状態
 
121
        JWWGLay GLay[16];       //レイヤグループ・レイヤ状態
 
122
        DWORD Dummy[14];        //ダミー
 
123
        DWORD m_lnSunpou1;      //寸法関係の設定
 
124
        DWORD m_lnSunpou2;
 
125
        DWORD m_lnSunpou3;
 
126
        DWORD m_lnSunpou4;
 
127
        DWORD m_lnSunpou5;
 
128
        DWORD Dummy1;   //ダミー
 
129
        DWORD m_nMaxDrawWid;//線描画の最大幅
 
130
        DPoint m_DPPrtGenten;   //プリンタ出力範囲の原点(X,Y)
 
131
        DOUBLE m_dPrtBairitsu;  //プリンタ出力倍率
 
132
        DWORD m_nPrt90Kaiten;   //プリンタ90°回転出力、プリンタ出力基準点位置
 
133
        DWORD m_nMemoriMode;    //目盛設定モード
 
134
        DOUBLE m_dMemoriHyoujiMin;      //目盛表示最小間隔ドット
 
135
        DOUBLE m_dMemoriX;      //目盛表示間隔X
 
136
        DOUBLE m_dMemoriY;      //目盛表示間隔Y
 
137
        DPoint m_DpMemoriKijunTen;      //目盛基準点(X,Y)
 
138
        string m_aStrLayName[16][16];   //レイヤ名
 
139
        string m_aStrGLayName[16];      //レイヤグループ名
 
140
        DOUBLE m_dKageLevel;    //日影計算の条件 測定面高さ
 
141
        DOUBLE m_dKageIdo;      //緯度
 
142
        DWORD m_nKage9_15Flg;   //9縲・5の測定の指定
 
143
        DOUBLE m_dKabeKageLevel;        //壁面日影測定面高さ
 
144
        DOUBLE m_dTenkuuZuLevel;        //天空図の条件（Ver.3.00以降) 測定面高さ
 
145
        DOUBLE m_dTenkuuZuEnkoR;        //天空図の半径＊２
 
146
        DWORD m_nMMTani3D;      //2.5Dの計算単位(0以外はmm単位で計算)
 
147
        DOUBLE m_dBairitsu;     //保存時の画面倍率(読込むと前画面倍率になる)
 
148
        DPoint m_DPGenten;
 
149
        DOUBLE m_dHanniBairitsu;        //範囲記憶倍率と基準点(X,Y)
 
150
        DPoint m_DPHanniGenten;
 
151
        JWWZoom m_dZoom[9];     //マークジャンプ倍率、基準点(X,Y)およびレイヤグループ
 
152
    DOUBLE dDm11;   //ダミー
 
153
    DOUBLE dDm12;   //ダミー
 
154
    DOUBLE dDm13;   //ダミー
 
155
    DWORD  lnDm1;   //ダミー
 
156
    DOUBLE dDm21;   //ダミー
 
157
    DOUBLE dDm22;   //ダミー
 
158
    DOUBLE m_dMojiBG;   //(Ver.4.04以前はダミー）文字列範囲を背景色で描画するときの範囲増寸法
 
159
        DWORD  m_nMojiBG;
 
160
    DOUBLE m_adFukusenSuuchi[10];       //複線間隔
 
161
        DOUBLE m_dRyoygawaFukusenTomeDe;        //両側複線の留線出の寸法
 
162
        JWWPen m_Pen[10];       //色番号ごとの画面表示色、線幅
 
163
        JWWPrtPen m_PrtPen[10]; //色番号ごとのプリンタ出力色、線幅、実点半径
 
164
        JWWLType1 m_alLType1[10];//線種番号2から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
165
        JWWLType2 m_alLType2[16]; //ランダム線1から5までのパターン、画面表示振幅・ピッチ、プリンタ出力振幅・ピッチ
 
166
        JWWLType3 m_alLType3[20]; //倍長線種番号6から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
167
        DWORD m_nDrawGamenTen;  //実点を画面描画時の指定半径で描画
 
168
        DWORD m_nDrawPrtTen;    //実点をプリンタ出力時、指定半径で書く
 
169
        DWORD m_nBitMapFirstDraw;       //BitMap・ソリッドを最初に描画する
 
170
        DWORD m_nGyakuDraw;     //逆描画
 
171
        DWORD m_nGyakuSearch;   //逆サーチ
 
172
        DWORD m_nColorPrint;    //カラー印刷
 
173
        DWORD m_nLayJunPrint;   //レイヤ順の印刷
 
174
        DWORD m_nColJunPrint;   //色番号順の印刷
 
175
        DWORD m_nPrtRenzoku;    //レイヤグループまたはレイヤごとのプリンタ連続出力指定
 
176
        DWORD m_nPrtKyoutuuGray;        //プリンタ共通レイヤ(表示のみレイヤ)のグレー出力指定
 
177
        DWORD m_nPrtDispOnlyNonDraw;    //プリンタ出力時に表示のみレイヤは出力しない
 
178
        DWORD m_lnDrawTime;     //作図時間（Ver.2.23以降）
 
179
        DWORD nEyeInit; //2.5Dの始点位置が設定されている時のフラグ（Ver.2.23以降）
 
180
        DWORD m_dEye_H_Ichi_1;  //2.5Dの透視図・鳥瞰図・アイソメ図の視点水平角（Ver.2.23以降）
 
181
        DWORD m_dEye_H_Ichi_2;  //
 
182
        DWORD m_dEye_H_Ichi_3;  //
 
183
        DOUBLE m_dEye_Z_Ichi_1; //2.5Dの透視図の視点高さ・視点離れ（Ver.2.23以降）
 
184
        DOUBLE m_dEye_Y_Ichi_1; //
 
185
        DOUBLE m_dEye_Z_Ichi_2; //2.5Dの鳥瞰図の視点高さ・視点離れ（Ver.2.23以降）
 
186
        DOUBLE m_dEye_Y_Ichi_2; //
 
187
        DOUBLE m_dEye_V_Ichi_3; //2.5Dのアイソメ図の視点垂直角（Ver.2.23以降）
 
188
        DOUBLE m_dSenNagasaSunpou;      //線の長さ指定の最終値（Ver.2.25以降）
 
189
        DOUBLE m_dBoxSunpouX;   //矩形寸法横寸法・縦寸法指定の最終値（Ver.2.25以降）
 
190
        DOUBLE m_dBoxSunpouY;
 
191
        DOUBLE m_dEnHankeySunpou;       //円の半径指定の最終値（Ver.2.25以降）
 
192
        DWORD m_nSolidNinniColor;       //ソリッドを任意色で書くフラグ、ソリッドの任意色の既定値（Ver.2.30以降）
 
193
        DWORD m_SolidColor;     //RGB
 
194
        SXFCOL  m_SxfCol;       //SXF対応拡張線色定義（Ver.4.20以降）
 
195
        SXFLTP  m_SxfLtp;       //SXF対応拡張線種定義（Ver.4.20以降）
 
196
        JWWaMoji m_Moji[11];//文字種1から10までの文字幅、高さ、間隔、色番号
 
197
        DOUBLE m_dMojiSizeX;    //書込み文字の文字幅
 
198
        DOUBLE m_dMojiSizeY;    //書込み文字の高さ
 
199
        DOUBLE m_dMojiKankaku;  //間隔
 
200
        DWORD m_nMojiColor;     //色番号
 
201
        DWORD m_nMojiShu;       //文字番号
 
202
        DOUBLE m_dMojiSeiriGyouKan;     //文字位置整理の行間
 
203
        DOUBLE m_dMojiSeiriSuu; //文字数
 
204
        DWORD m_nMojiKijunZureOn;       //文字基準点のずれ位置使用のフラグ
 
205
        DOUBLE m_adMojiKijunZureX[3];   //文字基準点の横方向のずれ位置左、中、右
 
206
        DOUBLE m_adMojiKijunZureY[3];   //文字基準点の縦方向のずれ位置下、中、上
 
207
        JWWHead(){;}
 
208
        ~JWWHead(){;}
 
209
        
 
210
};
 
211
 
 
212
//図形データの基底クラス
 
213
class   CData
 
214
{
 
215
protected:
 
216
        DWORD nOldVersionSave;  //バージョンNo.
 
217
public:
 
218
        DWORD m_lGroup;//曲線属性番号
 
219
        BYTE m_nPenStyle;//線種番号
 
220
        WORD m_nPenColor;//線色番号
 
221
/////////////////////////////////////////////////
 
222
        WORD m_nPenWidth;//線色幅 Ver.3.51以降
 
223
/////////////////////////////////////////////////
 
224
        WORD m_nLayer;//レイヤ番号
 
225
        WORD m_nGLayer;//レイヤグループ番号
 
226
        WORD m_sFlg;//属性フラグ
 
227
        CData(){;}
 
228
        ~CData(){;}
 
229
        const char* className(){return "CData";}
 
230
        friend inline std::ostream& operator<<(std::ostream&, const CData&); 
 
231
        friend inline std::istream& operator>>(std::istream&, CData&); 
 
232
        void SetVersion(DWORD ver){ nOldVersionSave = ver; }
 
233
        void Serialize(std::ofstream& ofstr){
 
234
       ofstr << (DWORD)m_lGroup;      //曲線属性番号
 
235
       ofstr << (BYTE)m_nPenStyle;   //線種番号
 
236
       ofstr << (WORD)m_nPenColor;   //線色番号
 
237
       if( nOldVersionSave >= 351 ){   //Ver.3.51以降
 
238
            ofstr << (WORD)m_nPenWidth;//線色幅
 
239
        }
 
240
        ofstr << (WORD)m_nLayer;      //レイヤ番号
 
241
        ofstr << (WORD)m_nGLayer;     //レイヤグループ番号
 
242
        ofstr << (WORD)m_sFlg;        //属性フラグ
 
243
        }
 
244
        void Serialize(std::ifstream& ifstr){
 
245
       ifstr >> /*(DWORD)*/m_lGroup;      //曲線属性番号
 
246
       ifstr >> /*(BYTE)*/m_nPenStyle;   //線種番号
 
247
       ifstr >> /*(WORD)*/m_nPenColor;   //線色番号
 
248
       if( nOldVersionSave >= 351 ){   //Ver.3.51以降
 
249
            ifstr >> /*(WORD)*/m_nPenWidth;//線色幅
 
250
        }
 
251
        ifstr >> /*(WORD)*/m_nLayer;      //レイヤ番号
 
252
        ifstr >> /*(WORD)*/m_nGLayer;     //レイヤグループ番号
 
253
        ifstr >> /*(WORD)*/m_sFlg;        //属性フラグ
 
254
        }
 
255
};
 
256
inline std::ostream& operator<< (std::ostream& ostr, const CData& output) 
 
257
{
 
258
       ostr << "曲線属性番号:" << (DWORD)output.m_lGroup;      //曲線属性番号
 
259
       ostr << "線種番号:" << (BYTE)output.m_nPenStyle;   //線種番号
 
260
       ostr << "線色番号:" << (WORD)output.m_nPenColor;   //線色番号
 
261
       if( output.nOldVersionSave >= 351 ){   //Ver.3.51以降
 
262
            ostr << "線色幅:" << (WORD)output.m_nPenWidth;//線色幅
 
263
        }
 
264
        ostr << "レイヤ番号:" << (WORD)output.m_nLayer;      //レイヤ番号
 
265
        ostr << "レイヤグループ番号:" << (WORD)output.m_nGLayer;     //レイヤグループ番号
 
266
        ostr << "属性フラグ:" << (WORD)output.m_sFlg;        //属性フラグ
 
267
        return ostr;
 
268
} 
 
269
 
 
270
inline std::istream& operator>> (std::istream& istr, CData& input) 
 
271
{
 
272
       istr >> input.m_lGroup;      //曲線属性番号
 
273
       istr >> input.m_nPenStyle;   //線種番号
 
274
       istr >> input.m_nPenColor;   //線色番号
 
275
       if( input.nOldVersionSave >= 351 ){   //Ver.3.51以降
 
276
            istr >> input.m_nPenWidth;//線色幅
 
277
        }
 
278
        istr >> input.m_nLayer;      //レイヤ番号
 
279
        istr >> input.m_nGLayer;     //レイヤグループ番号
 
280
        istr >> input.m_sFlg;        //属性フラグ
 
281
//      ifstr.read((char*)&(input.data), sizeof(int));
 
282
        return istr;
 
283
}
 
284
/*
 
285
属性フラグ(m_sFlg)
 
286
-------------------------------------------------------------------------------
 
287
データ    線      円      実点    文字          ブロック    寸法     ソリッド
 
288
-------------------------------------------------------------------------------
 
289
(0x0010)          図形    図形    寸法値
 
290
(0x0020)ハッチ    ハッチ  ハッチ  縦字                               ハッチ
 
291
(0x0040)          寸法    寸法    真北
 
292
(0x0080)          建具    建具    日影
 
293
(0x0100)                          半径寸法値
 
294
(0x0200)                          直径寸法値
 
295
(0x0400)                          角度寸法値
 
296
(0x0800)図形                      図形属性選択   図形 
 
297
(0x1000)建具                      累計寸法値     建具 
 
298
(0x2000)寸法                      建具           寸法      寸法
 
299
(0x4000)                          寸法
 
300
(0x8000)包絡処理対象外の建具      2.5D
 
301
-------------------------------------------------------------------------------
 
302
*/
 
303
 
 
304
//線分データ
 
305
class   CDataSen        :       public  CData
 
306
{
 
307
public:
 
308
        DPoint m_start;//始点X座標、Y座標
 
309
        DPoint m_end;//終点X座標、Y座標
 
310
        CDataSen(){;}
 
311
        ~CDataSen(){;}
 
312
        const char* className(){return "CDataSen";}
 
313
        friend inline std::ostream& operator<<(std::ostream&, const CDataSen&); 
 
314
        friend inline std::istream& operator>>(std::istream&, CDataSen&); 
 
315
        void Serialize(std::ofstream& ofstr)
 
316
#ifdef _MSC_VER // TODO VC 7.1 gives overload error.
 
317
        ;
 
318
#else
 
319
        {
 
320
            CData::Serialize(ofstr);
 
321
                ofstr   << (double)m_start.x << (double)m_start.y 
 
322
                                << (double)m_end.x << (double)m_end.y;
 
323
        }
 
324
#endif
 
325
        void Serialize(std::ifstream& ifstr){
 
326
            CData::Serialize(ifstr);
 
327
                ifstr   >> m_start.x >> m_start.y
 
328
                                >> m_end.x >> m_end.y;
 
329
        }
 
330
};
 
331
inline std::ostream& operator<< (std::ostream& ostr, const CDataSen& output) 
 
332
{
 
333
        ostr    << (double)output.m_start.x << " " << (double)output.m_start.y  << endl
 
334
                        << (double)output.m_end.x << " " << (double)output.m_end.y << endl;
 
335
        return ostr;
 
336
} 
 
337
 
 
338
inline std::istream& operator>> (std::istream& istr, CDataSen& input) 
 
339
{
 
340
        istr    >> input.m_start.x >> input.m_start.y
 
341
                        >> input.m_end.x >> input.m_end.y;
 
342
        return istr;
 
343
}
 
344
typedef CDataSen*       PCDataSen;
 
345
 
 
346
//円弧データ
 
347
class   CDataEnko       :       public  CData
 
348
{
 
349
public:
 
350
        DPoint m_start;//中心点X座標、Y座標
 
351
        DOUBLE m_dHankei;//半径
 
352
        DOUBLE m_radKaishiKaku;//開始角
 
353
        DOUBLE m_radEnkoKaku;//円弧角
 
354
        DOUBLE m_radKatamukiKaku;//傾き角
 
355
        DOUBLE m_dHenpeiRitsu;//扁平率
 
356
        DWORD m_bZenEnFlg;//全円フラグ
 
357
        CDataEnko(){;}
 
358
        ~CDataEnko(){;}
 
359
        const char* className(){return "CDataEnko";}
 
360
        friend inline std::ostream& operator<<(std::ostream&, const CDataEnko&); 
 
361
        friend inline std::istream& operator>>(std::istream&, CDataEnko&); 
 
362
        void Serialize(std::ofstream& ofstr)
 
363
#ifdef _MSC_VER
 
364
        ;
 
365
#else
 
366
        {
 
367
            CData::Serialize(ofstr);
 
368
            ofstr       << (double)m_start.x << (double)m_start.y
 
369
                                << (double)m_dHankei
 
370
                                << (double)m_radKaishiKaku
 
371
                                << (double)m_radEnkoKaku
 
372
                                << (double)m_radKatamukiKaku
 
373
                                << (double)m_dHenpeiRitsu
 
374
                                << (DWORD )m_bZenEnFlg;
 
375
        }
 
376
#endif
 
377
        void Serialize(std::ifstream& ifstr){
 
378
            CData::Serialize(ifstr);
 
379
                ifstr >> /*(double)*/m_start.x >> /*(double)*/m_start.y
 
380
                        >> /*(double)*/m_dHankei
 
381
                        >> /*(double)*/m_radKaishiKaku
 
382
                        >> /*(double)*/m_radEnkoKaku
 
383
                        >> /*(double)*/m_radKatamukiKaku
 
384
                        >> /*(double)*/m_dHenpeiRitsu
 
385
                        >> /*(DWORD)*/m_bZenEnFlg;
 
386
        }
 
387
};
 
388
typedef CDataEnko*      PCDataEnko;
 
389
inline std::ostream& operator<< (std::ostream& ostr, const CDataEnko& output)
 
390
{
 
391
        ostr    << (double)output.m_start.x << " " << (double)output.m_start.y << endl
 
392
                                << (double)output.m_dHankei << endl
 
393
                                << (double)output.m_radKaishiKaku << endl
 
394
                                << (double)output.m_radEnkoKaku << endl
 
395
                                << (double)output.m_radKatamukiKaku << endl
 
396
                                << (double)output.m_dHenpeiRitsu << endl
 
397
                                << (DWORD )output.m_bZenEnFlg << endl;
 
398
        return ostr;
 
399
} 
 
400
 
 
401
inline std::istream& operator>> (std::istream& istr, CDataEnko& input) 
 
402
{
 
403
                istr >> input.m_start.x >> input.m_start.y
 
404
                        >> input.m_dHankei
 
405
                        >> input.m_radKaishiKaku
 
406
                        >> input.m_radEnkoKaku
 
407
                        >> input.m_radKatamukiKaku
 
408
                        >> input.m_dHenpeiRitsu
 
409
                        >> input.m_bZenEnFlg;
 
410
        return istr;
 
411
}
 
412
 
 
413
//点データ
 
414
class   CDataTen        :       public  CData
 
415
{
 
416
public:
 
417
        DPoint m_start; //点X座標、Y座標
 
418
        DWORD m_bKariten;//仮点フラグ
 
419
        DWORD m_nCode;  //m_nPenStyleが「100」のとき点コード（矢印・ポイントマーカー）
 
420
        DOUBLE m_radKaitenKaku; //表示角
 
421
        DOUBLE m_dBairitsu;     //表示倍率
 
422
        CDataTen(){;}
 
423
        ~CDataTen(){;}
 
424
        const char* className(){return "CDataTen";}
 
425
        friend inline std::ostream& operator<<(std::ostream&, const CDataTen&); 
 
426
        friend inline std::istream& operator>>(std::istream&, CDataTen&); 
 
427
        void Serialize(std::ofstream& ofstr)
 
428
#ifdef _MSC_VER
 
429
        ;
 
430
#else
 
431
        {
 
432
            m_nPenStyle = 1;
 
433
            if( nOldVersionSave >= 252 ){   //Ver.2.52以降
 
434
                if( 0 != m_nCode ){ m_nPenStyle = 100; }
 
435
            }
 
436
            CData::Serialize(ofstr);
 
437
 
 
438
            ofstr << (double)m_start.x << (double)m_start.y;
 
439
            ofstr << (DWORD)m_bKariten;
 
440
            if( 100 == m_nPenStyle ){
 
441
                ofstr << (DWORD )m_nCode;
 
442
                ofstr << (double)m_radKaitenKaku;
 
443
                ofstr << (double)m_dBairitsu;
 
444
            }
 
445
        }
 
446
#endif
 
447
        void Serialize(std::ifstream& ifstr){
 
448
            CData::Serialize(ifstr);
 
449
        ifstr >> m_start.x >> m_start.y;
 
450
        ifstr >> m_bKariten;
 
451
        if( 100 == m_nPenStyle ){
 
452
            ifstr >> m_nCode;
 
453
            ifstr >> m_radKaitenKaku;
 
454
            ifstr >> m_dBairitsu;
 
455
       }
 
456
        }
 
457
};
 
458
typedef CDataTen*       PCDataTen;
 
459
inline std::ostream& operator<< (std::ostream& ostr, const CDataTen& output) 
 
460
{
 
461
        ostr << "x:" <<(double)output.m_start.x << " y:" << (double)output.m_start.y << endl;
 
462
        ostr << (DWORD)output.m_bKariten << endl;
 
463
        if( 100 == output.m_nPenStyle ){
 
464
            ostr << (DWORD )output.m_nCode << endl;
 
465
            ostr << (double)output.m_radKaitenKaku << endl;
 
466
            ostr << (double)output.m_dBairitsu << endl;
 
467
        }
 
468
        return ostr;
 
469
} 
 
470
 
 
471
inline std::istream& operator>> (std::istream& istr, CDataTen& /*input*/)
 
472
{
 
473
        return istr;
 
474
}
 
475
 
 
476
//文字データ
 
477
class   CDataMoji       :       public  CData
 
478
{
 
479
public:
 
480
        DPoint m_start;//始点X座標、Y座標
 
481
        DPoint m_end;//終点X座標、Y座標
 
482
        DWORD m_nMojiShu;//文字種(斜体文字は20000、ボールド体は10000を加えた数値)
 
483
        DOUBLE m_dSizeX;//文字サイズ横
 
484
        DOUBLE m_dSizeY;//文字サイズ縦
 
485
        DOUBLE m_dKankaku;//文字間隔
 
486
        DOUBLE m_degKakudo;//角度
 
487
        string m_strFontName;//フォント名
 
488
        string m_string;//文字列
 
489
        CDataMoji(){;}
 
490
        ~CDataMoji(){;}
 
491
        const char* className(){return "CDataEnko";}
 
492
        friend inline std::ostream& operator<<(std::ostream&, const CDataMoji&); 
 
493
        friend inline std::istream& operator>>(std::istream&, CDataMoji&); 
 
494
        void Serialize(std::ofstream& ofstr)
 
495
#ifdef _MSC_VER
 
496
        ;
 
497
#else
 
498
        {
 
499
////////////////////////////////////////////
 
500
//SKIP        m_nPenWidth = m_nSunpouFlg; //  (寸法値設定のフラグ)ヘッダーメンバー
 
501
        CData::Serialize(ofstr);
 
502
        m_nPenWidth = 1;            //文字枠幅を1
 
503
//SKIP        if( m_sMojiFlg & 0x0001 ){ m_nMojiShu += 10000; }  //斜体文字
 
504
//SKIP        if( m_sMojiFlg & 0x0010 ){ m_nMojiShu += 20000; }  //ボールド
 
505
 
 
506
        ofstr << (double)m_start.x << (double)m_start.y 
 
507
           << (double)m_end.x << (double)m_end.y
 
508
           << (DWORD)m_nMojiShu
 
509
           << (double)m_dSizeX << (double)m_dSizeY
 
510
           << (double)m_dKankaku
 
511
           << (double)m_degKakudo;
 
512
 
 
513
                int len = m_strFontName.length();
 
514
                if( len == 0 ){
 
515
                        ofstr << (BYTE)0x0;
 
516
                }else
 
517
                {
 
518
                        if( len >= 0xFF ){
 
519
                                ofstr << (BYTE)0xFF;
 
520
                                ofstr << (WORD)len;
 
521
                        }else{
 
522
                                ofstr << (BYTE)len;
 
523
                        }
 
524
                        ofstr.write(m_strFontName.c_str(),len);
 
525
                }
 
526
                len = m_string.length();
 
527
                if( len == 0 ){
 
528
                        ofstr << (BYTE)0x0;
 
529
                }else
 
530
                {
 
531
                        if( len >= 0xFF ){
 
532
                                ofstr << (BYTE)0xFF;
 
533
                                ofstr << (WORD)len;
 
534
                        }else{
 
535
                                ofstr << (BYTE)len;
 
536
                        }
 
537
                        ofstr.write(m_string.c_str(),len);
 
538
                }
 
539
        m_nMojiShu = (m_nMojiShu % 10000);
 
540
        }
 
541
#endif
 
542
        void Serialize(std::ifstream& ifstr){
 
543
        CData::Serialize(ifstr);
 
544
        ifstr >> m_start.x >> m_start.y 
 
545
           >> m_end.x >> m_end.y
 
546
           >> m_nMojiShu
 
547
           >> m_dSizeX >> m_dSizeY
 
548
           >> m_dKankaku
 
549
           >> m_degKakudo;
 
550
                BYTE bt;
 
551
                WORD wd;
 
552
         char buf[512];
 
553
                        ifstr >> bt;
 
554
                        if( bt != 0xFF ){
 
555
                                ifstr.read(buf,bt);
 
556
                                buf[bt] = '\0';
 
557
                                m_strFontName = buf;
 
558
#ifdef  DATA_DUMP
 
559
cout << "MojiData1:" << m_strFontName << endl;
 
560
#endif
 
561
                        }else
 
562
                        {
 
563
                                ifstr >> wd;
 
564
                                ifstr.read(buf,wd);
 
565
                                buf[wd] = '\0';
 
566
                                m_strFontName = buf;
 
567
#ifdef  DATA_DUMP
 
568
cout << "MojiData2:" << m_strFontName << endl;
 
569
#endif
 
570
                        }
 
571
                        ifstr >> bt;
 
572
                        if( bt != 0xFF ){
 
573
                                ifstr.read(buf,bt);
 
574
                                buf[bt] = '\0';
 
575
                                m_string = buf;
 
576
#ifdef  DATA_DUMP
 
577
cout << "MojiData3:"  << m_string << endl;
 
578
#endif
 
579
                        }else
 
580
                        {
 
581
                                ifstr >> wd;
 
582
                                ifstr.read(buf,wd);
 
583
                                buf[wd] = '\0';
 
584
                                m_string = buf;
 
585
#ifdef  DATA_DUMP
 
586
cout << "MojiData4:"  << m_string << endl;
 
587
#endif
 
588
                        }
 
589
/*        m_nPenWidth = 1;            //文字枠幅を1
 
590
        if( m_sMojiFlg & 0x0001 ){ m_nMojiShu += 10000; }  //斜体文字
 
591
        if( m_sMojiFlg & 0x0010 ){ m_nMojiShu += 20000; }  //ボールド
 
592
        m_nMojiShu = (m_nMojiShu % 10000);
 
593
        m_nPenWidth = m_nSunpouFlg; //  (寸法値設定のフラグ)
 
594
*/
 
595
        }
 
596
};
 
597
typedef CDataMoji*      PCDataMoji;
 
598
inline std::ostream& operator<< (std::ostream& ostr, const CDataMoji& /*output*/)
 
599
{
 
600
        return ostr;
 
601
} 
 
602
 
 
603
inline std::istream& operator>> (std::istream& istr, CDataMoji& /*input*/)
 
604
{
 
605
        return istr;
 
606
}
 
607
 
 
608
 
 
609
//寸法データ
 
610
class   CDataSunpou     :       public  CData
 
611
{
 
612
public:
 
613
        CDataSen m_Sen; //線分メンバ
 
614
        CDataMoji m_Moji;       //文字メンバ
 
615
        WORD m_bSxfMode;        //SXFのモード
 
616
        CDataSen m_SenHo1;      //補助線1
 
617
        CDataSen m_SenHo2;      //補助線2
 
618
        CDataTen m_Ten1;        //矢印（点)1
 
619
        CDataTen m_Ten2;        //矢印（点)2
 
620
        CDataTen m_TenHo1;      //基準点1
 
621
        CDataTen m_TenHo2;      //基準点2
 
622
        CDataSunpou(){;}
 
623
        ~CDataSunpou(){;}
 
624
        const char* className(){return "CDataSunpou";}
 
625
        friend inline std::ostream& operator<<(std::ostream&, const CDataSunpou&); 
 
626
        friend inline std::istream& operator>>(std::istream&, CDataSunpou&); 
 
627
        void Serialize(std::ofstream& ofstr){
 
628
            CData::Serialize(ofstr);
 
629
        m_Sen .Serialize(ofstr);
 
630
        m_Moji.Serialize(ofstr);
 
631
        if( nOldVersionSave >= 420 ){  //Ver.4.20以降
 
632
            ofstr << (WORD )m_bSxfMode;
 
633
            m_SenHo1 .Serialize(ofstr);
 
634
            m_SenHo2 .Serialize(ofstr);
 
635
            m_Ten1   .Serialize(ofstr);
 
636
            m_Ten2   .Serialize(ofstr);
 
637
            m_TenHo1 .Serialize(ofstr);
 
638
            m_TenHo2 .Serialize(ofstr);
 
639
        }
 
640
        }
 
641
        void Serialize(std::ifstream& ifstr){
 
642
            CData::Serialize(ifstr);
 
643
        m_Sen .Serialize(ifstr);
 
644
        m_Moji.Serialize(ifstr);
 
645
        if( nOldVersionSave >= 420 ){  //Ver.4.20以降
 
646
            ifstr >> m_bSxfMode;
 
647
            m_SenHo1 .Serialize(ifstr);
 
648
            m_SenHo2 .Serialize(ifstr);
 
649
            m_Ten1   .Serialize(ifstr);
 
650
            m_Ten2   .Serialize(ifstr);
 
651
            m_TenHo1 .Serialize(ifstr);
 
652
            m_TenHo2 .Serialize(ifstr);
 
653
        }
 
654
        }
 
655
};
 
656
typedef CDataSunpou* PCDataSunpou;
 
657
inline std::ostream& operator<< (std::ostream& ostr, const CDataSunpou& /*output*/)
 
658
{
 
659
        return ostr;
 
660
} 
 
661
 
 
662
inline std::istream& operator>> (std::istream& istr, CDataSunpou& /*input*/)
 
663
{
 
664
        return istr;
 
665
}
 
666
/*
 
667
m_nPenWidth = m_nSunpouFlg; //  (寸法値設定のフラグ)
 
668
「寸法値設定のフラグ」は次のようになる
 
669
---------------------------------------------
 
670
    0x0002  寸法の文字設定有のフラグ
 
671
    0x0008  全角文字
 
672
    0x0010  寸法単位
 
673
    0x0020  寸法単位追加
 
674
    0x0040  ３桁毎のカンマ表示
 
675
    0x0080  少数点以下の０表示
 
676
    0x0100  少数桁以下  切捨（切捨、切上指定以外は四捨五入）
 
677
    0x0200  少数桁以下  切上
 
678
    0x0400  "φ" 、"R"  前付
 
679
    0x0800  "φ" 、"R"  後付
 
680
    0x1000  少数点以下の桁数 1
 
681
    0x2000  少数点以下の桁数 2
 
682
    0x3000  少数点以下の桁数 3
 
683
---------------------------------------------
 
684
*/
 
685
 
 
686
//ソリッドデータ
 
687
class   CDataSolid      :       public  CData
 
688
{
 
689
public:
 
690
        DPoint m_start;//第1点X座標、Y座標
 
691
        DPoint m_end;//第4点4座標、Y座標
 
692
        DPoint m_DPoint2;//第2点X座標、Y座標
 
693
        DPoint m_DPoint3;//第3点X座標、Y座標
 
694
        DWORD m_Color;//塗潰し色のRGB値(任意色の場合のみ)
 
695
        CDataSolid(){;}
 
696
        ~CDataSolid(){;}
 
697
        const char* className(){return "CDataSolid";}
 
698
        friend inline std::ostream& operator<<(std::ostream&, const CDataSolid&); 
 
699
        friend inline std::istream& operator>>(std::istream&, CDataSolid&); 
 
700
        void Serialize(std::ofstream& ofstr)
 
701
#ifdef _MSC_VER
 
702
        ;
 
703
#else
 
704
        {
 
705
            CData::Serialize(ofstr);
 
706
            ofstr << (double)m_start.x << (double)m_start.y 
 
707
                << (double)m_end.x << (double)m_end.y
 
708
                << (double)m_DPoint2.x << (double)m_DPoint2.y
 
709
                << (double)m_DPoint3.x << (double)m_DPoint3.y;
 
710
            if( 10 == m_nPenColor ){
 
711
                ofstr << (DWORD)m_Color;//RGB
 
712
            }
 
713
        }
 
714
#endif
 
715
        void Serialize(std::ifstream& ifstr){
 
716
            CData::Serialize(ifstr);
 
717
        ifstr >> m_start.x >> m_start.y 
 
718
           >> m_end.x >> m_end.y
 
719
           >> m_DPoint2.x >> m_DPoint2.y
 
720
           >> m_DPoint3.x >> m_DPoint3.y;
 
721
        if( 10 == m_nPenColor ){
 
722
                ifstr >> m_Color;//RGB
 
723
        }
 
724
        }
 
725
};
 
726
typedef CDataSolid*     PCDataSolid;
 
727
inline std::ostream& operator<< (std::ostream& ostr, const CDataSolid& /*output*/)
 
728
{
 
729
        return ostr;
 
730
} 
 
731
 
 
732
inline std::istream& operator>> (std::istream& istr, CDataSolid& /*input*/)
 
733
{
 
734
        return istr;
 
735
}
 
736
 
 
737
//部品データ
 
738
class   CDataBlock      :       public  CData
 
739
{
 
740
public:
 
741
        DPoint m_DPKijunTen;//基準点X座標、Y座標
 
742
        DOUBLE m_dBairitsuX;//X方向の倍率
 
743
        DOUBLE m_dBairitsuY;//Y方向の倍率
 
744
        DOUBLE m_radKaitenKaku;//回転角
 
745
        DWORD m_n_Number;//ブロック定義データの通し番号
 
746
        CDataBlock(){;}
 
747
        ~CDataBlock(){;}
 
748
        const char* className(){return "CDataBlock";}
 
749
        friend inline std::ostream& operator<<(std::ostream&, const CDataBlock&); 
 
750
        friend inline std::istream& operator>>(std::istream&, CDataBlock&); 
 
751
        void Serialize(std::ofstream& ofstr)
 
752
#ifdef _MSC_VER
 
753
        ;
 
754
#else
 
755
        {
 
756
            CData::Serialize(ofstr);
 
757
        ofstr <<(double)m_DPKijunTen.x <<(double)m_DPKijunTen.y
 
758
           <<(double)m_dBairitsuX
 
759
           <<(double)m_dBairitsuY
 
760
           <<(double)m_radKaitenKaku
 
761
           <</*(DWORD)m_pDataList->*/m_n_Number;//ポインタでなく通し番号を保存する
 
762
        }
 
763
#endif
 
764
        void Serialize(std::ifstream& ifstr){
 
765
            CData::Serialize(ifstr);
 
766
        ifstr >> m_DPKijunTen.x >> m_DPKijunTen.y
 
767
           >> m_dBairitsuX
 
768
           >> m_dBairitsuY
 
769
           >> m_radKaitenKaku
 
770
           >>/*(DWORD)m_pDataList->*/m_n_Number;//ポインタでなく通し番号を保存する
 
771
        }
 
772
};
 
773
typedef CDataBlock*     PCDataBlock;
 
774
inline std::ostream& operator<< (std::ostream& ostr, const CDataBlock& /*output*/)
 
775
{
 
776
        return ostr;
 
777
} 
 
778
 
 
779
inline std::istream& operator>> (std::istream& istr, CDataBlock& /*input*/)
 
780
{
 
781
        return istr;
 
782
}
 
783
 
 
784
//ブロック定義データ
 
785
class   CDataList       :       public  CData
 
786
{
 
787
public:
 
788
        DWORD m_nNumber;        //定義データの通し番号
 
789
        DWORD m_bReffered;      //参照されているかのフラグ
 
790
        DWORD m_time;   //定義された時間
 
791
        string m_strName;       //定義データの名前
 
792
                                                //Ver.4.10 以降、名前の後ろに
 
793
                        //"@@SfigorgFlag@@"に続けて、複合図形種別フラグを付加
 
794
                        //1:部分図(数学座標系)、2: 部分図(測地座標系)、
 
795
                        //3:作図グループ、4:作図部品
 
796
        vector<CData*> m_DataList;      //定義データの実体のリスト
 
797
        WORD Count;     //テスト用
 
798
        CDataList(){;}
 
799
        ~CDataList(){;}
 
800
        const char* className(){return "CDataList";}
 
801
        friend inline std::ostream& operator<<(std::ostream&, const CDataList&); 
 
802
        friend inline std::istream& operator>>(std::istream&, CDataList&); 
 
803
        void Serialize(std::ofstream& ofstr){
 
804
            CData::Serialize(ofstr);
 
805
        ofstr <<(DWORD)m_nNumber
 
806
                <<(DWORD)m_bReffered
 
807
           <<m_time;
 
808
        //Ver.4.10 以降、名前の後ろに
 
809
        //"@@SfigorgFlag@@"に続けて、複合図形種別フラグを付加
 
810
        //1:部分図(数学座標系)、2: 部分図(測地座標系)、
 
811
        //3:作図グループ、4:作図部品
 
812
                int len = m_strName.length();
 
813
                if( len == 0 ){
 
814
                        ofstr << (BYTE)0x0;
 
815
                }else
 
816
                {
 
817
                        if( len >= 0xFF ){
 
818
                                ofstr << (BYTE)0xFF;
 
819
                                ofstr << (WORD)len;
 
820
                        }else{
 
821
                                ofstr << (BYTE)len;
 
822
                        }
 
823
                        ofstr.write(m_strName.c_str(), len);
 
824
                }
 
825
            //SKIP m_DataList.Serialize(ofstr);
 
826
        }
 
827
        void Serialize(std::ifstream& ifstr){
 
828
            CData::Serialize(ifstr);
 
829
        ifstr >> m_nNumber
 
830
           >> m_bReffered
 
831
           >> m_time;
 
832
                //Ver.4.10 以降、名前の後ろに
 
833
                //"@@SfigorgFlag@@"に続けて、複合図形種別フラグを付加
 
834
                //1:部分図(数学座標系)、2: 部分図(測地座標系)、
 
835
                //3:作図グループ、4:作図部品
 
836
                BYTE bt;
 
837
                WORD wd;
 
838
                char buf[512];
 
839
                ifstr >> bt;
 
840
                if( bt != 0xFF ){
 
841
                        ifstr.read(buf,bt);
 
842
                        buf[bt] = '\0';
 
843
                        m_strName = buf;
 
844
#ifdef  DATA_DUMP
 
845
cout << "MojiData1:"  << m_strName << endl;
 
846
#endif
 
847
                }else
 
848
                {
 
849
                        ifstr >> wd;
 
850
                        ifstr.read(buf,wd);
 
851
                        buf[wd] = '\0';
 
852
                        m_strName = buf;
 
853
#ifdef  DATA_DUMP
 
854
cout << "MojiData1:"  << m_strName << endl;
 
855
#endif
 
856
                }
 
857
            //SKIP m_DataList.Serialize(ifstr);
 
858
        }
 
859
};
 
860
typedef CDataList* PCDataList;
 
861
inline std::ostream& operator<< (std::ostream& ostr, const CDataList& /*output*/)
 
862
{
 
863
        return ostr;
 
864
} 
 
865
 
 
866
inline std::istream& operator>> (std::istream& istr, CDataList& /*input*/)
 
867
{
 
868
        return istr;
 
869
}
 
870
 
 
871
//図形要素
 
872
typedef enum{
 
873
        Sen,
 
874
        Enko,
 
875
        Ten,
 
876
        Moji,
 
877
        Sunpou,
 
878
        Solid,
 
879
        Block
 
880
}CDataType;
 
881
typedef CDataType* PCDataType;
 
882
 
 
883
//
 
884
// ブロックデータの実体のクラス
 
885
// DataTypeプロパティーを読んでから振り分けてDataSenなどで読み込む
 
886
//
 
887
class   JWWBlockList
 
888
{
 
889
private:
 
890
        vector<PCDataBlock> FBlockList;
 
891
        vector<PCDataList> FDataList;
 
892
        vector<CDataType> FDataType;
 
893
protected:
 
894
public:
 
895
    CDataList& GetBlockList(unsigned int i);
 
896
        int getBlockListCount();
 
897
    int GetDataListCount(unsigned int i);
 
898
    void* GetData(unsigned int i, int j );
 
899
    CDataType GetDataType(unsigned int i, int j );
 
900
 
 
901
        CDataEnko& GetCDataEnko(int i, int j );
 
902
        CDataMoji& GetCDataMoji(int i, int j );
 
903
        CDataSen& GetCDataSen(int i, int j );
 
904
        CDataSolid& GetCDataSolid(int i, int j );
 
905
        CDataSunpou& GetCDataSunpou(int i, int j );
 
906
        CDataTen& GetCDataTen(int i, int j );
 
907
        CDataType GetCDataType(int i, int j );
 
908
        CDataBlock& GetCDataBlock(int i, int j );
 
909
 
 
910
        void AddBlockList(CDataList& CData);
 
911
        void AddDataListSen(CDataSen& D);
 
912
        void AddDataListEnko(CDataEnko& D);
 
913
        void AddDataListTen(CDataTen& D);
 
914
        void AddDataListMoji(CDataMoji& D);
 
915
        void AddDataListSolid(CDataSolid& D);
 
916
        void AddDataListSunpou(CDataSunpou& D);
 
917
        void AddDataListBlock(CDataBlock& D);
 
918
        JWWBlockList();
 
919
        ~JWWBlockList();
 
920
        void Init();
 
921
};
 
922
 
 
923
//図形番号リスト
 
924
typedef struct  _NoList{
 
925
        string CDataString;
 
926
        int No;
 
927
}NoList;
 
928
typedef NoList* PNoList;
 
929
 
 
930
//データ格納リスト
 
931
class   JWWList
 
932
{
 
933
private:
 
934
        vector<PNoList> FList;
 
935
 
 
936
protected:
 
937
public:
 
938
        JWWList();
 
939
        ~JWWList();
 
940
        int GetCount();
 
941
        NoList& GetItem(int i);
 
942
        NoList& GetNoByItem(int i);
 
943
        void AddItem(int No,string& str);
 
944
};
 
945
 
 
946
//JWWファイル入出力クラス
 
947
class   JWWDocument
 
948
{
 
949
private:
 
950
        string  InputFName,
 
951
                        OutputFName;
 
952
public:
 
953
        JWWDocument(string& iFName, string& oFName){
 
954
                InputFName = iFName;
 
955
                if(iFName.length()>0)
 
956
                        ifs = new ifstream(iFName.c_str(),ios::binary);
 
957
                else
 
958
                        ifs = NULL;
 
959
                OutputFName = oFName;
 
960
                if(oFName.length()>0)
 
961
                        ofs = new ofstream(oFName.c_str(),ios::binary|ios::trunc);
 
962
                else
 
963
                        ofs = NULL;
 
964
                pList = new JWWList();
 
965
                pBlockList = new JWWBlockList();
 
966
        }
 
967
        ~JWWDocument(){
 
968
                delete pList;
 
969
                delete pBlockList;
 
970
                if(ifs){
 
971
                        ifs->close();
 
972
                        delete ifs;
 
973
                }
 
974
                if(ofs){
 
975
                        ofs->close();
 
976
                        delete ofs;
 
977
                }
 
978
        }
 
979
// 各図形のレコードの実体
 
980
        JWWHead Header;
 
981
        ifstream*       ifs;
 
982
        ofstream*       ofs;
 
983
        WORD objCode;
 
984
        DWORD Mpoint;
 
985
        DWORD PSen;
 
986
        DWORD PEnko;
 
987
        DWORD PTen;
 
988
        DWORD PMoji;
 
989
        DWORD PSunpou;
 
990
        DWORD PSolid;
 
991
        DWORD PBlock;
 
992
        DWORD PList;
 
993
        DWORD SenCount;
 
994
        DWORD EnkoCount;
 
995
        DWORD TenCount;
 
996
        DWORD MojiCount;
 
997
        DWORD SolidCount;
 
998
        DWORD BlockCount;
 
999
        DWORD SunpouCount;
 
1000
    DWORD SaveSenCount;
 
1001
    DWORD SaveEnkoCount;
 
1002
    DWORD SaveTenCount;
 
1003
    DWORD SaveMojiCount;
 
1004
    DWORD SaveSunpouCount;
 
1005
    DWORD SaveSolidCount;
 
1006
    DWORD SaveBlockCount;
 
1007
    DWORD SaveDataListCount;
 
1008
 
 
1009
        vector<CDataSen>        vSen;//
 
1010
        vector<CDataEnko>       vEnko;//
 
1011
        vector<CDataTen>        vTen;//
 
1012
        vector<CDataMoji>       vMoji;//
 
1013
        vector<CDataSolid>      vSolid;//
 
1014
        vector<CDataBlock>      vBlock;//
 
1015
        vector<CDataSunpou>     vSunpou;//
 
1016
        JWWList*        pList;//
 
1017
        JWWBlockList*   pBlockList;//ブロックデータ定義部のリスト
 
1018
        vector<CData*>   m_DataList;    //図形データのリスト
 
1019
        vector<CDataList*>      m_DataListList;  //ブロックデータ定義部のリスト
 
1020
        void WriteString(string s);
 
1021
        string ReadData(int n);
 
1022
        string ReadString();
 
1023
        BOOL ReadHeader();
 
1024
        BOOL WriteHeader();
 
1025
        BOOL Read();
 
1026
        BOOL Save();
 
1027
        BOOL SaveBich16(DWORD id);
 
1028
        BOOL SaveSen(CDataSen& DSen);
 
1029
        BOOL SaveEnko(CDataEnko& DEnko);
 
1030
        BOOL SaveTen(CDataTen& DTen);
 
1031
        BOOL SaveMoji(CDataMoji& DMoji);
 
1032
        BOOL SaveSunpou(CDataSunpou& DSunpou);
 
1033
        BOOL SaveSolid(CDataSolid& DSolid);
 
1034
        BOOL SaveBlock(CDataBlock& DBlock);
 
1035
        BOOL SaveDataList(CDataList& DList);
 
1036
};
 
1037
 
 
1038
#endif //JWWDOC_H