← Back to branch summary

~librecad-dev/librecad/librecad

« back to all changes in this revision

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

  • 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.cpp
 
1
#include "jwwdoc.h"
 
2
 
 
3
#define LINEBUF_SIZE    1024
 
4
 
 
5
#ifdef _MSC_VER
 
6
void CDataSen::Serialize(std::ofstream& ofstr)
 
7
{
 
8
    CData::Serialize(ofstr);
 
9
    ofstr       << (double)m_start.x << (double)m_start.y
 
10
        << (double)m_end.x << (double)m_end.y;
 
11
}
 
12
 
 
13
void CDataEnko::Serialize(std::ofstream& ofstr)
 
14
{
 
15
    CData::Serialize(ofstr);
 
16
    ofstr       << (double)m_start.x << (double)m_start.y
 
17
        << (double)m_dHankei
 
18
        << (double)m_radKaishiKaku
 
19
        << (double)m_radEnkoKaku
 
20
        << (double)m_radKatamukiKaku
 
21
        << (double)m_dHenpeiRitsu
 
22
        << (DWORD )m_bZenEnFlg;
 
23
}
 
24
 
 
25
void CDataTen::Serialize(std::ofstream& ofstr)
 
26
{
 
27
    m_nPenStyle = 1;
 
28
    if( nOldVersionSave >= 252 ){   //Ver.2.52以降
 
29
        if( 0 != m_nCode ){ m_nPenStyle = 100; }
 
30
    }
 
31
 
 
32
    CData::Serialize(ofstr);
 
33
 
 
34
    ofstr << (double)m_start.x << (double)m_start.y;
 
35
    ofstr << (DWORD)m_bKariten;
 
36
    if( 100 == m_nPenStyle ){
 
37
        ofstr << (DWORD )m_nCode;
 
38
        ofstr << (double)m_radKaitenKaku;
 
39
        ofstr << (double)m_dBairitsu;
 
40
    }
 
41
}
 
42
 
 
43
void CDataMoji::Serialize(std::ofstream& ofstr)
 
44
{
 
45
////////////////////////////////////////////
 
46
//SKIP        m_nPenWidth = m_nSunpouFlg; //  (寸法値設定のフラグ)ヘッダーメンバー
 
47
        CData::Serialize(ofstr);
 
48
        m_nPenWidth = 1;            //文字枠幅を1
 
49
//SKIP        if( m_sMojiFlg & 0x0001 ){ m_nMojiShu += 10000; }  //斜体文字
 
50
//SKIP        if( m_sMojiFlg & 0x0010 ){ m_nMojiShu += 20000; }  //ボールド
 
51
 
 
52
        ofstr << (double)m_start.x << (double)m_start.y
 
53
           << (double)m_end.x << (double)m_end.y
 
54
           << (DWORD)m_nMojiShu
 
55
           << (double)m_dSizeX << (double)m_dSizeY
 
56
           << (double)m_dKankaku
 
57
           << (double)m_degKakudo;
 
58
 
 
59
        int len = m_strFontName.length();
 
60
        if( len == 0 ){
 
61
            ofstr << (BYTE)0x0;
 
62
        }else
 
63
        {
 
64
            if( len >= 0xFF ){
 
65
                ofstr << (BYTE)0xFF;
 
66
                ofstr << (WORD)len;
 
67
            }else{
 
68
                ofstr << (BYTE)len;
 
69
            }
 
70
            ofstr.write(m_strFontName.c_str(),len);
 
71
        }
 
72
        len = m_string.length();
 
73
        if( len == 0 ){
 
74
            ofstr << (BYTE)0x0;
 
75
        }else
 
76
        {
 
77
            if( len >= 0xFF ){
 
78
                ofstr << (BYTE)0xFF;
 
79
                ofstr << (WORD)len;
 
80
            }else{
 
81
                ofstr << (BYTE)len;
 
82
            }
 
83
            ofstr.write(m_string.c_str(),len);
 
84
        }
 
85
        m_nMojiShu = (m_nMojiShu % 10000);
 
86
}
 
87
 
 
88
void CDataSolid::Serialize(std::ofstream& ofstr)
 
89
{
 
90
    CData::Serialize(ofstr);
 
91
    ofstr << (double)m_start.x << (double)m_start.y
 
92
        << (double)m_end.x << (double)m_end.y
 
93
        << (double)m_DPoint2.x << (double)m_DPoint2.y
 
94
        << (double)m_DPoint3.x << (double)m_DPoint3.y;
 
95
    if( 10 == m_nPenColor ){
 
96
        ofstr << (DWORD)m_Color;//RGB
 
97
    }
 
98
}
 
99
 
 
100
void CDataBlock::Serialize(std::ofstream& ofstr)
 
101
{
 
102
    CData::Serialize(ofstr);
 
103
    ofstr <<(double)m_DPKijunTen.x <<(double)m_DPKijunTen.y
 
104
        <<(double)m_dBairitsuX
 
105
        <<(double)m_dBairitsuY
 
106
        <<(double)m_radKaitenKaku
 
107
        <</*(DWORD)m_pDataList->*/m_n_Number;//ポインタでなく通し番号を保存する
 
108
}
 
109
 
 
110
#endif
 
111
 
 
112
void JWWDocument::WriteString(string s){
 
113
    int len = s.length();
 
114
    if( len == 0 ){
 
115
        *ofs << (BYTE)0x0;
 
116
        return;
 
117
    }else if( len >= 0xFF ){
 
118
        *ofs << (BYTE)0xFF;
 
119
        *ofs << (WORD)len;
 
120
    }else{
 
121
        *ofs << (BYTE)len;
 
122
    }
 
123
    ofs->write(s.c_str(), len);
 
124
}
 
125
 
 
126
string JWWDocument::ReadData(int n)
 
127
{
 
128
    //avoid buffer overflow
 
129
    if(n>LINEBUF_SIZE){
 
130
        //should not happen
 
131
        std::cerr<<"JWWDocument::ReadData("<<n<<"): requested data length is larger than "<<LINEBUF_SIZE<<std::endl;
 
132
    }
 
133
    string      Result;
 
134
    Result.resize(n);
 
135
    if( n > 0 )
 
136
        ifs->read(&(Result[0]), n);
 
137
//    Result += '\0'; // may not be necessary, to make sure the string ends with '\0';
 
138
    return Result;
 
139
 
 
140
//      char cbuf[LINEBUF_SIZE];
 
141
//      cbuf[0] = (char)NULL;
 
142
//      if( n > 0 )
 
143
//              ifs->read(cbuf, n);
 
144
//      cbuf[n] = (char)NULL;
 
145
//      string  Result(cbuf, n);
 
146
//      return  Result;
 
147
}
 
148
 
 
149
string JWWDocument::ReadString()
 
150
{
 
151
    BYTE bt;
 
152
    WORD wd;
 
153
    string      Result("");
 
154
    *ifs >> bt;
 
155
    if( bt == 0 )
 
156
        return Result;
 
157
    else if( bt != 0xFF )
 
158
        Result = ReadData(bt);
 
159
    else
 
160
    {
 
161
        *ifs >> wd;
 
162
        Result = ReadData(wd);
 
163
    }
 
164
    return      Result;
 
165
}
 
166
 
 
167
//ヘッダー部読みだし(JWW形式とバージョンチェック)
 
168
BOOL JWWDocument::ReadHeader()
 
169
{
 
170
    int i;
 
171
    DWORD dw;
 
172
    DOUBLE db;
 
173
    string s;
 
174
//    WORD wd;
 
175
//    BYTE bt;
 
176
//    BOOL      Result = false;
 
177
 
 
178
    if(ifs)
 
179
    {
 
180
        //JWWのデータファイルの宣言
 
181
        s = ReadData(8);
 
182
        Header.head = s;
 
183
        if(Header.head =="JwwData.")
 
184
        {
 
185
            //バージョンNo.
 
186
            *ifs >> dw;
 
187
            Header.JW_DATA_VERSION = dw;
 
188
            if(Header.JW_DATA_VERSION == 230 || Header.JW_DATA_VERSION >= 300)
 
189
            {
 
190
                //ファイルメモ
 
191
                Header.m_strMemo = ReadString();
 
192
                //図面サイズ
 
193
                //0縲・ ：A0縲廣4
 
194
                //8    ：2 A
 
195
                //9    ：3 A
 
196
                //10   ：4 A
 
197
                //11   ：5 A
 
198
                //12   ：10m
 
199
                //13   ：50m
 
200
                //14   ：100m
 
201
                *ifs >> dw;
 
202
                Header.m_nZumen = dw;
 
203
                //レイヤグループ・レイヤ状態
 
204
                *ifs >> dw;
 
205
                Header.m_nWriteGLay = dw;
 
206
                for( i = 0; i < 16; i++ ){
 
207
                    *ifs >> dw;
 
208
                    Header.GLay[i].m_anGLay = dw;
 
209
                    *ifs >> dw;
 
210
                    Header.GLay[i].m_anWriteLay = dw;
 
211
                    *ifs >> db;
 
212
                    Header.GLay[i].m_adScale = db;
 
213
                    *ifs >> dw;
 
214
                    Header.GLay[i].m_anGLayProtect = dw;
 
215
                    for(int nLay=0;nLay<16;nLay++){
 
216
                        *ifs >> dw;
 
217
                        Header.GLay[i].m_nLay[nLay].m_aanLay = dw;
 
218
                        *ifs >> dw;
 
219
                        Header.GLay[i].m_nLay[nLay].m_aanLayProtect = dw;
 
220
                    }
 
221
                }
 
222
                //ダミー
 
223
                for( i = 0; i < 14; i++ )
 
224
                {
 
225
                    *ifs >> dw;
 
226
                    Header.Dummy[i]=dw;
 
227
                }
 
228
                //寸法関係の設定
 
229
                *ifs >> dw;
 
230
                Header.m_lnSunpou1 = dw;
 
231
                *ifs >> dw;
 
232
                Header.m_lnSunpou2 = dw;
 
233
                *ifs >> dw;
 
234
                Header.m_lnSunpou3 = dw;
 
235
                *ifs >> dw;
 
236
                Header.m_lnSunpou4 = dw;
 
237
                *ifs >> dw;
 
238
                Header.m_lnSunpou5 = dw;
 
239
                //ダミー
 
240
                *ifs >> dw;
 
241
                Header.Dummy1 = dw;
 
242
                //線描画の最大幅
 
243
                //「線幅を1/100mm単位とする」が設定されているときは「-101」
 
244
                *ifs >> dw;
 
245
                Header.m_nMaxDrawWid = dw;
 
246
                //プリンタ出力範囲の原点(X,Y)
 
247
                *ifs >> db;
 
248
                Header.m_DPPrtGenten.x = db;
 
249
                //
 
250
                *ifs >> db;
 
251
                Header.m_DPPrtGenten.y = db;
 
252
                //プリンタ出力倍率
 
253
                *ifs >> db;
 
254
                Header.m_dPrtBairitsu = db;
 
255
                //プリンタ90°回転出力、プリンタ出力基準点位置
 
256
                *ifs >> dw;
 
257
                Header.m_nPrt90Kaiten = dw;
 
258
                //目盛設定モード
 
259
                *ifs >> dw;
 
260
                Header.m_nMemoriMode = dw;
 
261
                //目盛表示最小間隔ドット
 
262
                *ifs >> db;
 
263
                Header.m_dMemoriHyoujiMin = db;
 
264
                //目盛表示間隔(X,Y)
 
265
                *ifs >> db;
 
266
                Header.m_dMemoriX = db;
 
267
                //
 
268
                *ifs >> db;
 
269
                Header.m_dMemoriY = db;
 
270
                //目盛基準点(X,Y)
 
271
                *ifs >> db;
 
272
                Header.m_DpMemoriKijunTen.x = db;
 
273
                //
 
274
                *ifs >> db;
 
275
                Header.m_DpMemoriKijunTen.y = db;
 
276
                //レイヤ名
 
277
                for( i=0; i < 16; i++)
 
278
                    for( int j = 0; j < 16; j++ )
 
279
                        Header.m_aStrLayName[i][j] = ReadString();
 
280
                //レイヤグループ名
 
281
                for( i=0; i < 16; i++ )
 
282
                    Header.m_aStrGLayName[i] = ReadString();
 
283
                //日影計算の条件 測定面高さ
 
284
                *ifs >> db;
 
285
                Header.m_dKageLevel = db;
 
286
                //緯度
 
287
                *ifs >> db;
 
288
                Header.m_dKageIdo = db;
 
289
                //9縲・5の測定の指定
 
290
                *ifs >> dw;
 
291
                Header.m_nKage9_15Flg = dw;
 
292
                //壁面日影測定面高さ
 
293
                *ifs >> db;
 
294
                Header.m_dKabeKageLevel = db;
 
295
                //天空図の条件（Ver.3.00以降)
 
296
                if(Header.JW_DATA_VERSION >= 300)
 
297
                {
 
298
                    //測定面高さ
 
299
                    *ifs >> db;
 
300
                    Header.m_dTenkuuZuLevel = db;
 
301
                    //天空図の半径＊２
 
302
                    *ifs >> db;
 
303
                    Header.m_dTenkuuZuEnkoR = db;
 
304
                }
 
305
                //2.5Dの計算単位(0以外はmm単位で計算)
 
306
                *ifs >> dw;
 
307
                Header.m_nMMTani3D = dw;
 
308
 
 
309
                //保存時の画面倍率(読込むと前画面倍率になる)
 
310
                *ifs >> db;
 
311
                Header.m_dBairitsu = db;
 
312
                //
 
313
                *ifs >> db;
 
314
                Header.m_DPGenten.x = db;
 
315
                //
 
316
                *ifs >> db;
 
317
                Header.m_DPGenten.y = db;
 
318
 
 
319
                //範囲記憶倍率と基準点(X,Y)
 
320
                *ifs >> db;
 
321
                Header.m_dHanniBairitsu = db;
 
322
                //
 
323
                *ifs >> db;
 
324
                Header.m_DPHanniGenten.x = db;
 
325
                //
 
326
                *ifs >> db;
 
327
                Header.m_DPHanniGenten.y = db;
 
328
 
 
329
                //マークジャンプ倍率、基準点(X,Y)およびレイヤグループ
 
330
                if(Header.JW_DATA_VERSION >= 300)
 
331
                {
 
332
                    //ズーム拡張(v300)
 
333
                    for(int n=1; n<=8; n++){
 
334
                        *ifs >> db;
 
335
                        Header.m_dZoom[n].m_dZoomJumpBairitsu = db;
 
336
                        *ifs >> db;
 
337
                        Header.m_dZoom[n].m_DPZoomJumpGenten.x = db;
 
338
                        *ifs >> db;
 
339
                        Header.m_dZoom[n].m_DPZoomJumpGenten.y = db;
 
340
                        *ifs >> dw;
 
341
                        Header.m_dZoom[n].m_nZoomJumpGLay = dw;
 
342
                    }
 
343
                } else
 
344
                {
 
345
                    for( i=1; i <= 4; i++ )
 
346
                    {
 
347
                        *ifs >> db;
 
348
                        Header.m_dZoom[i].m_dZoomJumpBairitsu = db;
 
349
                        *ifs >> db;
 
350
                        Header.m_dZoom[i].m_DPZoomJumpGenten.x = db;
 
351
                        *ifs >> db;
 
352
                        Header.m_dZoom[i].m_DPZoomJumpGenten.y = db;
 
353
                    }
 
354
                }
 
355
                //ダミー
 
356
                if( Header.JW_DATA_VERSION >= 300 ){   //Ver.3.00以降
 
357
                    *ifs >> db;
 
358
                    Header.dDm11 = db;
 
359
                    *ifs >> db;
 
360
                    Header.dDm12 = db;
 
361
                    *ifs >> db;
 
362
                    Header.dDm13 = db;
 
363
                    *ifs >> dw;
 
364
                    Header.lnDm1 = dw;
 
365
                    *ifs >> db;
 
366
                    Header.dDm21 = db;
 
367
                    *ifs >> db;
 
368
                    Header.dDm22 = db;
 
369
                    //(Ver.4.04以前はダミー）文字列範囲を背景色で描画するときの範囲増寸法
 
370
                    *ifs >> db;
 
371
                    Header.m_dMojiBG = db;
 
372
                    //(Ver.4.04以前はダミー）
 
373
                    //十位:文字（寸法図形、ブロック図形）を最後に描画
 
374
                    //一位:1 :輪郭・範囲を背景色で描画しない
 
375
                    //     2 :文字の輪郭を背景色で描画する
 
376
                    //     3 :文字列範囲を背景色で描画する
 
377
                    *ifs >> dw;
 
378
                    Header.m_nMojiBG = dw;
 
379
                }
 
380
                //複線間隔
 
381
                for( i=0; i <= 9; i++ ){
 
382
                    *ifs >> db;
 
383
                    Header.m_adFukusenSuuchi[i] = db;
 
384
                }
 
385
                //両側複線の留線出の寸法
 
386
                *ifs >> db;
 
387
                Header.m_dRyoygawaFukusenTomeDe = db;
 
388
                //色番号ごとの画面表示色、線幅
 
389
                for( i=0; i <= 9; i++ ){
 
390
                    *ifs >> dw;
 
391
                    Header.m_Pen[i].m_m_aPenColor = dw;
 
392
                    *ifs >> dw;
 
393
                    Header.m_Pen[i].m_anPenWidth = dw;
 
394
                }
 
395
                //色番号ごとのプリンタ出力色、線幅、実点半径
 
396
                for( i=0; i <= 9; i++ ){
 
397
                    *ifs >> dw;
 
398
                    Header.m_PrtPen[i].m_aPrtpenColor = dw;
 
399
                    *ifs >> dw;
 
400
                    Header.m_PrtPen[i].m_anPrtPenWidth = dw;
 
401
                    *ifs >> db;
 
402
                    Header.m_PrtPen[i].m_adPrtTenHankei = db;
 
403
                }
 
404
                //線種番号2から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
405
                for( i=2; i <= 9; i++ ){
 
406
                    *ifs >> dw;
 
407
                    Header.m_alLType1[i].m_alLtype = dw;
 
408
                    *ifs >> dw;
 
409
                    Header.m_alLType1[i].m_anTokushusSenUnitDot = dw;
 
410
                    *ifs >> dw;
 
411
                    Header.m_alLType1[i].m_anTokushuSenPich = dw;
 
412
                    *ifs >> dw;
 
413
                    Header.m_alLType1[i].m_anPrtTokushuSenPich = dw;
 
414
                }
 
415
                //ランダム線1から5までのパターン、画面表示振幅・ピッチ、プリンタ出力振幅・ピッチ
 
416
                for( i=11; i <= 15; i++ ){
 
417
                    *ifs >> dw;
 
418
                    Header.m_alLType2[i].m_alLtype = dw;
 
419
                    *ifs >> dw;
 
420
                    Header.m_alLType2[i].m_anRandSenWide = dw;
 
421
                    *ifs >> dw;
 
422
                    Header.m_alLType2[i].m_anTokushuSenPich = dw;
 
423
                    *ifs >> dw;
 
424
                    Header.m_alLType2[i].m_anPrtRandSenWide = dw;
 
425
                    *ifs >> dw;
 
426
                    Header.m_alLType2[i].m_anPrtTokushuSenPich = dw;
 
427
                }
 
428
                //倍長線種番号6から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
429
                for( i=16; i <= 19; i++ ){
 
430
                    *ifs >> dw;
 
431
                    Header.m_alLType3[i].m_alLtype = dw;
 
432
                    *ifs >> dw;
 
433
                    Header.m_alLType3[i].m_anTokushusSenUnitDot = dw;
 
434
                    *ifs >> dw;
 
435
                    Header.m_alLType3[i].m_anTokushuSenPich = dw;
 
436
                    *ifs >> dw;
 
437
                    Header.m_alLType3[i].m_anPrtTokushuSenPich = dw;
 
438
                }
 
439
                //実点を画面描画時の指定半径で描画
 
440
                *ifs >> dw;
 
441
                Header.m_nDrawGamenTen = dw;
 
442
                //実点をプリンタ出力時、指定半径で書く
 
443
                *ifs >> dw;
 
444
                Header.m_nDrawPrtTen = dw;
 
445
                //BitMap・ソリッドを最初に描画する
 
446
                *ifs >> dw;
 
447
                Header.m_nBitMapFirstDraw = dw;
 
448
                //逆描画
 
449
                *ifs >> dw;
 
450
                Header.m_nGyakuDraw = dw;
 
451
                //逆サーチ
 
452
                *ifs >> dw;
 
453
                Header.m_nGyakuSearch = dw;
 
454
                //カラー印刷
 
455
                *ifs >> dw;
 
456
                Header.m_nColorPrint = dw;
 
457
                //レイヤ順の印刷
 
458
                *ifs >> dw;
 
459
                Header.m_nLayJunPrint = dw;
 
460
                //色番号順の印刷
 
461
                *ifs >> dw;
 
462
                Header.m_nColJunPrint = dw;
 
463
                //レイヤグループまたはレイヤごとのプリンタ連続出力指定
 
464
                *ifs >> dw;
 
465
                Header.m_nPrtRenzoku = dw;
 
466
                //プリンタ共通レイヤ(表示のみレイヤ)のグレー出力指定
 
467
                *ifs >> dw;
 
468
                Header.m_nPrtKyoutuuGray = dw;
 
469
                //プリンタ出力時に表示のみレイヤは出力しない
 
470
                *ifs >> dw;
 
471
                Header.m_nPrtDispOnlyNonDraw = dw;
 
472
                //作図時間（Ver.2.23以降）
 
473
                *ifs >> dw;
 
474
                Header.m_lnDrawTime = dw;
 
475
                //2.5Dの始点位置が設定されている時のフラグ（Ver.2.23以降）
 
476
                *ifs >> dw;
 
477
                Header.nEyeInit = dw;
 
478
                //2.5Dの透視図・鳥瞰図・アイソメ図の視点水平角（Ver.2.23以降）
 
479
                *ifs >> dw;
 
480
                Header.m_dEye_H_Ichi_1 = dw;
 
481
                //
 
482
                *ifs >> dw;
 
483
                Header.m_dEye_H_Ichi_2 = dw;
 
484
                //
 
485
                *ifs >> dw;
 
486
                Header.m_dEye_H_Ichi_3 = dw;
 
487
                //2.5Dの透視図の視点高さ・視点離れ（Ver.2.23以降）
 
488
                *ifs >> db;
 
489
                Header.m_dEye_Z_Ichi_1 = db;
 
490
                //
 
491
                *ifs >> db;
 
492
                Header.m_dEye_Y_Ichi_1 = db;
 
493
                //2.5Dの鳥瞰図の視点高さ・視点離れ（Ver.2.23以降）
 
494
                *ifs >> db;
 
495
                Header.m_dEye_Z_Ichi_2 = db;
 
496
                //
 
497
                *ifs >> db;
 
498
                Header.m_dEye_Y_Ichi_2 = db;
 
499
                //2.5Dのアイソメ図の視点垂直角（Ver.2.23以降）
 
500
                *ifs >> db;
 
501
                Header.m_dEye_V_Ichi_3 = db;
 
502
                //線の長さ指定の最終値（Ver.2.25以降）
 
503
                *ifs >> db;
 
504
                Header.m_dSenNagasaSunpou = db;
 
505
                //矩形寸法横寸法・縦寸法指定の最終値（Ver.2.25以降）
 
506
                *ifs >> db;
 
507
                Header.m_dBoxSunpouX = db;
 
508
                //
 
509
                *ifs >> db;
 
510
                Header.m_dBoxSunpouY = db;
 
511
                //円の半径指定の最終値（Ver.2.25以降）
 
512
                *ifs >> db;
 
513
                Header.m_dEnHankeySunpou = db;
 
514
                //ソリッドを任意色で書くフラグ、ソリッドの任意色の既定値（Ver.2.30以降）
 
515
                *ifs >> dw;
 
516
                Header.m_nSolidNinniColor = dw;
 
517
                //RGB
 
518
                *ifs >> dw;
 
519
                Header.m_SolidColor = dw;
 
520
                //SXF対応拡張線色定義（Ver.4.20以降）
 
521
                if(Header.JW_DATA_VERSION >= 420){
 
522
                    int n1;
 
523
                    for( int n=0; n <= 256; n++ ){ //////   画面表示色
 
524
                        n1 = n + SXCOL_EXT;   //色番号のオフセット = +100
 
525
                        *ifs >> dw;
 
526
                        Header.m_SxfCol.m_aPenColor[n1] = dw;
 
527
                        *ifs >> dw;
 
528
                        Header.m_SxfCol.m_anPenWidth[n1] = dw;
 
529
                    }
 
530
                    for( int n=0; n <= 256; n++ ){ //////   プリンタ出力色
 
531
                        Header.m_SxfCol.m_astrUDColorName[n] = ReadString();
 
532
                        n1 = n + SXCOL_EXT;   //色番号のオフセット = +100
 
533
                        *ifs >> dw;
 
534
                        Header.m_SxfCol.m_aPrtPenColor[n1] = dw;
 
535
                        *ifs >> dw;
 
536
                        Header.m_SxfCol.m_anPrtPenWidth[n1] = dw;
 
537
                        *ifs >> db;
 
538
                        Header.m_SxfCol.m_adPrtTenHankei[n1] = db;
 
539
                    }
 
540
                }
 
541
                //SXF対応拡張線種定義（Ver.4.20以降）
 
542
                if(Header.JW_DATA_VERSION >= 420){
 
543
                    int n1;
 
544
                    for( int n=0; n<=32; n++){   //////  線種パターン
 
545
                        n1 = n + SXLTP_EXT;   //線種番号のオフセット = +30
 
546
                        *ifs >> dw;
 
547
                        Header.m_SxfLtp.m_alLType[n1] = dw;
 
548
                        *ifs >> dw;
 
549
                        Header.m_SxfLtp.m_anTokushuSenUintDot[n1] = dw;
 
550
                        *ifs >> dw;
 
551
                        Header.m_SxfLtp.m_anTokushuSenPich[n1] = dw;
 
552
                        *ifs >> dw;
 
553
                        Header.m_SxfLtp.m_anPrtTokushuSenPich[n1] = dw;
 
554
                    }
 
555
                    for( int n=0; n<=32; n++){   //////  線種パラメータ
 
556
                        Header.m_SxfLtp.m_astrUDLTypeName[n] = ReadString();
 
557
                        *ifs >> dw;
 
558
                        Header.m_SxfLtp.m_anUDLTypeSegment[n] = dw;
 
559
                        for( int j=1; j<=10; j++){
 
560
                            *ifs >> db;
 
561
                            Header.m_SxfLtp.m_aadUDLTypePitch[n][j] = db;
 
562
                        }
 
563
                    }
 
564
                }
 
565
                //文字種1から10までの文字幅、高さ、間隔、色番号
 
566
                for(i=1; i<=10;i++){
 
567
                    *ifs >> db;
 
568
                    Header.m_Moji[i].m_adMojiX = db;
 
569
                    *ifs >> db;
 
570
                    Header.m_Moji[i].m_adMojiY = db;
 
571
                    *ifs >> db;
 
572
                    Header.m_Moji[i].m_adMojiD = db;
 
573
                    *ifs >> dw;
 
574
                    Header.m_Moji[i].m_anMojiCol = dw;
 
575
                }
 
576
                //書込み文字の文字幅
 
577
                *ifs >> db;
 
578
                Header.m_dMojiSizeX = db;
 
579
                //高さ
 
580
                *ifs >> db;
 
581
                Header.m_dMojiSizeY = db;
 
582
                //間隔
 
583
                *ifs >> db;
 
584
                Header.m_dMojiKankaku = db;
 
585
                //色番号
 
586
                *ifs >> dw;
 
587
                Header.m_nMojiColor = dw;
 
588
                //文字番号
 
589
                *ifs >> dw;
 
590
                Header.m_nMojiShu = dw;
 
591
                //文字位置整理の行間
 
592
                *ifs >> db;
 
593
                Header.m_dMojiSeiriGyouKan = db;
 
594
                //文字数
 
595
                *ifs >> db;
 
596
                Header.m_dMojiSeiriSuu = db;
 
597
                //文字基準点のずれ位置使用のフラグ
 
598
                *ifs >> dw;
 
599
                Header.m_nMojiKijunZureOn = dw;
 
600
                //文字基準点の横方向のずれ位置左
 
601
                *ifs >> db;
 
602
                Header.m_adMojiKijunZureX[0] = db;
 
603
                //中
 
604
                *ifs >> db;
 
605
                Header.m_adMojiKijunZureX[1] = db;
 
606
                //右
 
607
                *ifs >> db;
 
608
                Header.m_adMojiKijunZureX[2] = db;
 
609
                //文字基準点の縦方向のずれ位置下
 
610
                *ifs >> db;
 
611
                Header.m_adMojiKijunZureY[0] = db;
 
612
                //中
 
613
                *ifs >> db;
 
614
                Header.m_adMojiKijunZureY[1] = db;
 
615
                //上
 
616
                *ifs >> db;
 
617
                Header.m_adMojiKijunZureY[2] = db;
 
618
            }
 
619
        }else
 
620
            return false;
 
621
    }else
 
622
        return false;
 
623
    return true;
 
624
}
 
625
 
 
626
//ヘッダー部書き出し
 
627
BOOL JWWDocument::WriteHeader()
 
628
{
 
629
    DWORD dw;
 
630
//    WORD wd;
 
631
    DOUBLE db;
 
632
    string s;
 
633
 
 
634
    //JWWのデータファイルの宣言
 
635
    ofs->write("JwwData.",8);
 
636
    //バージョンNo.
 
637
    dw=Header.JW_DATA_VERSION;
 
638
    *ofs << dw;
 
639
    //ファイルメモ
 
640
    WriteString(Header.m_strMemo);
 
641
    //図面サイズ
 
642
    dw=Header.m_nZumen;
 
643
    *ofs << dw;
 
644
    //レイヤグループ・レイヤ状態
 
645
    dw=Header.m_nWriteGLay;
 
646
    *ofs << dw;
 
647
    for(int i = 0; i < 16; i++ ){
 
648
        dw = Header.GLay[i].m_anGLay;
 
649
        *ofs << dw;
 
650
        dw = Header.GLay[i].m_anWriteLay;
 
651
        *ofs << dw;
 
652
        db = Header.GLay[i].m_adScale;
 
653
        *ofs << db;
 
654
        dw = Header.GLay[i].m_anGLayProtect;
 
655
        *ofs << dw;
 
656
        for(int nLay=0;nLay<16;nLay++){
 
657
            dw = Header.GLay[i].m_nLay[nLay].m_aanLay;
 
658
            *ofs << dw;
 
659
            dw = Header.GLay[i].m_nLay[nLay].m_aanLayProtect;
 
660
            *ofs << dw;
 
661
        }
 
662
    }
 
663
    //ダミー
 
664
    for(int i = 0; i < 14; i++ )
 
665
    {
 
666
        dw=Header.Dummy[i];
 
667
        *ofs << dw;
 
668
    }
 
669
    //寸法関係の設定
 
670
    dw = Header.m_lnSunpou1;
 
671
    *ofs << dw;
 
672
    dw = Header.m_lnSunpou2;
 
673
    *ofs << dw;
 
674
    dw = Header.m_lnSunpou3;
 
675
    *ofs << dw;
 
676
    dw = Header.m_lnSunpou4;
 
677
    *ofs << dw;
 
678
    dw = Header.m_lnSunpou5;
 
679
    *ofs << dw;
 
680
    //ダミー
 
681
    dw = Header.Dummy1;
 
682
    *ofs << dw;
 
683
    //線描画の最大幅
 
684
    dw = Header.m_nMaxDrawWid;
 
685
    *ofs << dw;
 
686
    //プリンタ出力範囲の原点(X,Y)
 
687
    db = Header.m_DPPrtGenten.x;
 
688
    *ofs << db;
 
689
    //
 
690
    db = Header.m_DPPrtGenten.y;
 
691
    *ofs << db;
 
692
    //プリンタ出力倍率
 
693
    db = Header.m_dPrtBairitsu;
 
694
    *ofs << db;
 
695
    //プリンタ90°回転出力、プリンタ出力基準点位置
 
696
    dw = Header.m_nPrt90Kaiten;
 
697
    *ofs << dw;
 
698
    //目盛設定モード
 
699
    dw = Header.m_nMemoriMode;
 
700
    *ofs << dw;
 
701
    //目盛表示最小間隔ドット
 
702
    db = Header.m_dMemoriHyoujiMin;
 
703
    *ofs << db;
 
704
    //目盛表示間隔(X,Y)
 
705
    db = Header.m_dMemoriX;
 
706
    *ofs << db;
 
707
    //
 
708
    db = Header.m_dMemoriY;
 
709
    *ofs << db;
 
710
    //目盛基準点(X,Y)
 
711
    db = Header.m_DpMemoriKijunTen.x;
 
712
    *ofs << db;
 
713
    //
 
714
    db = Header.m_DpMemoriKijunTen.y;
 
715
    *ofs << db;
 
716
    //レイヤ名
 
717
    for(int i = 0; i < 16; i++ )
 
718
        for( int j = 0; j < 16; j++ )
 
719
            WriteString(Header.m_aStrLayName[i][j]);
 
720
    //レイヤグループ名
 
721
    for(int i = 0; i < 16; i++ )
 
722
        WriteString(Header.m_aStrGLayName[i]);
 
723
    //日影計算の条件 測定面高さ
 
724
    db = Header.m_dKageLevel;
 
725
    *ofs << db;
 
726
    //緯度
 
727
    db = Header.m_dKageIdo;
 
728
    *ofs << db;
 
729
    //9縲・5の測定の指定
 
730
    dw = Header.m_nKage9_15Flg;
 
731
    *ofs << dw;
 
732
    //壁面日影測定面高さ
 
733
    db = Header.m_dKabeKageLevel;
 
734
    *ofs << db;
 
735
    //天空図の条件（Ver.3.00以降) 測定面高さ
 
736
    if(Header.JW_DATA_VERSION >= 300)
 
737
    {
 
738
        db = Header.m_dTenkuuZuLevel;
 
739
        *ofs << db;
 
740
        //天空図の半径＊２
 
741
        db = Header.m_dTenkuuZuEnkoR;
 
742
        *ofs << db;
 
743
 
 
744
    }
 
745
    //2.5Dの計算単位(0以外はmm単位で計算)
 
746
    dw = Header.m_nMMTani3D;
 
747
    *ofs << dw;
 
748
    //保存時の画面倍率(読込むと前画面倍率になる)
 
749
    db = Header.m_dBairitsu;
 
750
    *ofs << db;
 
751
    //
 
752
    db = Header.m_DPGenten.x;
 
753
    *ofs << db;
 
754
    //
 
755
    db = Header.m_DPGenten.y;
 
756
    *ofs << db;
 
757
    //範囲記憶倍率と基準点(X,Y)
 
758
    db = Header.m_dHanniBairitsu;
 
759
    *ofs << db;
 
760
    //
 
761
    db = Header.m_DPHanniGenten.x;
 
762
    *ofs << db;
 
763
    //
 
764
    db = Header.m_DPHanniGenten.y;
 
765
    *ofs << db;
 
766
    //マークジャンプ倍率、基準点(X,Y)およびレイヤグループ
 
767
    if( Header.JW_DATA_VERSION >= 300 ){   //Ver.3.00以降
 
768
        for( int i=1; i<=8; i++ ){
 
769
            db = Header.m_dZoom[i].m_dZoomJumpBairitsu;
 
770
            *ofs << db;
 
771
            db = Header.m_dZoom[i].m_DPZoomJumpGenten.x;
 
772
            *ofs << db;
 
773
            db = Header.m_dZoom[i].m_DPZoomJumpGenten.y;
 
774
            *ofs << db;
 
775
            dw = Header.m_dZoom[i].m_nZoomJumpGLay;
 
776
            *ofs << dw;
 
777
        }
 
778
    }else{
 
779
        for( int i=1; i<=4; i++){
 
780
            db = Header.m_dZoom[i].m_dZoomJumpBairitsu;
 
781
            *ofs << db;
 
782
            db = Header.m_dZoom[i].m_DPZoomJumpGenten.x;
 
783
            *ofs << db;
 
784
            db = Header.m_dZoom[i].m_DPZoomJumpGenten.y;
 
785
            *ofs << db;
 
786
        }
 
787
    }
 
788
    //文字の描画状態(Ver.4.05以降）
 
789
    if( Header.JW_DATA_VERSION >= 300 ){   //Ver.3.00以降
 
790
        db = Header.dDm11;//ダミー
 
791
        *ofs << db;
 
792
        db = Header.dDm12;//ダミー
 
793
        *ofs << db;
 
794
        db = Header.dDm13;//ダミー
 
795
        *ofs << db;
 
796
        dw = Header.lnDm1;//ダミー
 
797
        *ofs << dw;
 
798
        db = Header.dDm21;//ダミー
 
799
        *ofs << db;
 
800
        db = Header.dDm22;//ダミー
 
801
        *ofs << db;
 
802
        db = Header.m_dMojiBG;//(Ver.4.04以前はダミー）
 
803
        *ofs << db;     //文字列範囲を背景色で描画するときの範囲増寸法
 
804
        dw = Header.m_nMojiBG;
 
805
        *ofs << dw;
 
806
    }
 
807
    //複線間隔
 
808
    for(int i = 0; i <= 9; i++ )
 
809
    {
 
810
        db = Header.m_adFukusenSuuchi[i];
 
811
        *ofs << db;
 
812
    }
 
813
    //両側複線の留線出の寸法
 
814
    db = Header.m_dRyoygawaFukusenTomeDe;
 
815
    *ofs << db;
 
816
    //色番号ごとの画面表示色、線幅
 
817
    for(int i = 0; i <= 9; i++ )
 
818
    {
 
819
        dw = Header.m_Pen[i].m_m_aPenColor;
 
820
        *ofs << dw;
 
821
        dw = Header.m_Pen[i].m_anPenWidth;
 
822
        *ofs << dw;
 
823
    }
 
824
    //色番号ごとのプリンタ出力色、線幅、実点半径
 
825
    for(int i = 0; i <= 9; i++ )
 
826
    {
 
827
        dw = Header.m_PrtPen[i].m_aPrtpenColor;
 
828
        *ofs << dw;
 
829
        dw = Header.m_PrtPen[i].m_anPrtPenWidth;
 
830
        *ofs << dw;
 
831
        db = Header.m_PrtPen[i].m_adPrtTenHankei;
 
832
        *ofs << db;
 
833
    }
 
834
    //線種番号2から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
835
    for(int i = 2; i <= 9; i++ )
 
836
    {
 
837
        dw = Header.m_alLType1[i].m_alLtype;
 
838
        *ofs << dw;
 
839
        dw = Header.m_alLType1[i].m_anTokushusSenUnitDot;
 
840
        *ofs << dw;
 
841
        dw = Header.m_alLType1[i].m_anTokushuSenPich;
 
842
        *ofs << dw;
 
843
        dw = Header.m_alLType1[i].m_anPrtTokushuSenPich;
 
844
        *ofs << dw;
 
845
    }
 
846
    //ランダム線1から5までのパターン、画面表示振幅・ピッチ、プリンタ出力振幅・ピッチ
 
847
    for(int i = 11; i <= 15; i++ )
 
848
    {
 
849
        dw = Header.m_alLType2[i].m_alLtype;
 
850
        *ofs << dw;
 
851
        dw = Header.m_alLType2[i].m_anRandSenWide;
 
852
        *ofs << dw;
 
853
        dw = Header.m_alLType2[i].m_anTokushuSenPich;
 
854
        *ofs << dw;
 
855
        dw = Header.m_alLType2[i].m_anPrtRandSenWide;
 
856
        *ofs << dw;
 
857
        dw = Header.m_alLType2[i].m_anPrtTokushuSenPich;
 
858
        *ofs << dw;
 
859
    }
 
860
    //倍長線種番号6から9までのパターン、1ユニットのドット数、ピッチ、プリンタ出力ピッチ
 
861
    for(int i = 16; i <= 19; i++ )
 
862
    {
 
863
        dw = Header.m_alLType3[i].m_alLtype;
 
864
        *ofs << dw;
 
865
        dw = Header.m_alLType3[i].m_anTokushusSenUnitDot;
 
866
        *ofs << dw;
 
867
        dw = Header.m_alLType3[i].m_anTokushuSenPich;
 
868
        *ofs << dw;
 
869
        dw = Header.m_alLType3[i].m_anPrtTokushuSenPich;
 
870
        *ofs << dw;
 
871
    }
 
872
    //実点を画面描画時の指定半径で描画
 
873
    dw = Header.m_nDrawGamenTen;
 
874
    *ofs << dw;
 
875
    //実点をプリンタ出力時、指定半径で書く
 
876
    dw = Header.m_nDrawPrtTen;
 
877
    *ofs << dw;
 
878
    //BitMap・ソリッドを最初に描画する
 
879
    dw = Header.m_nBitMapFirstDraw;
 
880
    *ofs << dw;
 
881
    //逆描画
 
882
    dw = Header.m_nGyakuDraw;
 
883
    *ofs << dw;
 
884
    //逆サーチ
 
885
    dw = Header.m_nGyakuSearch;
 
886
    *ofs << dw;
 
887
    //カラー印刷
 
888
    dw = Header.m_nColorPrint;
 
889
    *ofs << dw;
 
890
    //レイヤ順の印刷
 
891
    dw = Header.m_nLayJunPrint;
 
892
    *ofs << dw;
 
893
    //色番号順の印刷
 
894
    dw = Header.m_nColJunPrint;
 
895
    *ofs << dw;
 
896
    //レイヤグループまたはレイヤごとのプリンタ連続出力指定
 
897
    dw = Header.m_nPrtRenzoku;
 
898
    *ofs << dw;
 
899
    //プリンタ共通レイヤ(表示のみレイヤ)のグレー出力指定
 
900
    dw = Header.m_nPrtKyoutuuGray;
 
901
    *ofs << dw;
 
902
    //プリンタ出力時に表示のみレイヤは出力しない
 
903
    dw = Header.m_nPrtDispOnlyNonDraw;
 
904
    *ofs << dw;
 
905
    //作図時間（Ver.2.23以降）
 
906
    dw = Header.m_lnDrawTime;
 
907
    *ofs << dw;
 
908
    //2.5Dの始点位置が設定されている時のフラグ（Ver.2.23以降）
 
909
    dw = Header.nEyeInit;
 
910
    *ofs << dw;
 
911
    //2.5Dの透視図・鳥瞰図・アイソメ図の視点水平角（Ver.2.23以降）
 
912
    dw = Header.m_dEye_H_Ichi_1;
 
913
    *ofs << dw;
 
914
    //
 
915
    dw = Header.m_dEye_H_Ichi_2;
 
916
    *ofs << dw;
 
917
    //
 
918
    dw = Header.m_dEye_H_Ichi_3;
 
919
    *ofs << dw;
 
920
    //2.5Dの透視図の視点高さ・視点離れ（Ver.2.23以降）
 
921
    db = Header.m_dEye_Z_Ichi_1;
 
922
    *ofs << db;
 
923
    //
 
924
    db = Header.m_dEye_Y_Ichi_1;
 
925
    *ofs << db;
 
926
    //2.5Dの鳥瞰図の視点高さ・視点離れ（Ver.2.23以降）
 
927
    db = Header.m_dEye_Z_Ichi_2;
 
928
    *ofs << db;
 
929
    //
 
930
    db = Header.m_dEye_Y_Ichi_2;
 
931
    *ofs << db;
 
932
    //2.5Dのアイソメ図の視点垂直角（Ver.2.23以降）
 
933
    db = Header.m_dEye_V_Ichi_3;
 
934
    *ofs << db;
 
935
    //線の長さ指定の最終値（Ver.2.25以降）
 
936
    db = Header.m_dSenNagasaSunpou;
 
937
    *ofs << db;
 
938
    //矩形寸法横寸法・縦寸法指定の最終値（Ver.2.25以降）
 
939
    db = Header.m_dBoxSunpouX;
 
940
    *ofs << db;
 
941
    //
 
942
    db = Header.m_dBoxSunpouY;
 
943
    *ofs << db;
 
944
    //円の半径指定の最終値（Ver.2.25以降）
 
945
    db = Header.m_dEnHankeySunpou;
 
946
    *ofs << db;
 
947
    //ソリッドを任意色で書くフラグ、ソリッドの任意色の既定値（Ver.2.30以降）
 
948
    dw = Header.m_nSolidNinniColor;
 
949
    *ofs << dw;
 
950
    //RGB
 
951
    dw = Header.m_SolidColor;
 
952
    *ofs << dw;
 
953
    //SXF対応拡張線色定義（Ver.4.20以降）
 
954
    if( Header.JW_DATA_VERSION >= 420 ){
 
955
        int n1;
 
956
        for( int n=0; n<=256; n++){ //   画面表示色
 
957
            n1 = n + SXCOL_EXT;   //色番号のオフセット = +100
 
958
            dw = Header.m_SxfCol.m_aPenColor[n1];
 
959
            *ofs << dw;
 
960
            dw = Header.m_SxfCol.m_anPenWidth[n1];
 
961
            *ofs << dw;
 
962
        }
 
963
        for( int n=0; n<=256; n++){ //   プリンタ出力色
 
964
            WriteString(Header.m_SxfCol.m_astrUDColorName[n]);
 
965
            n1 = n + SXCOL_EXT;   //色番号のオフセット = +100
 
966
            dw = Header.m_SxfCol.m_aPrtPenColor[n1];
 
967
            *ofs << dw;
 
968
            dw = Header.m_SxfCol.m_anPrtPenWidth[n1];
 
969
            *ofs << dw;
 
970
            db = Header.m_SxfCol.m_adPrtTenHankei[n1];
 
971
            *ofs << db;
 
972
        }
 
973
    }
 
974
    //SXF対応拡張線種定義（Ver.4.20以降）
 
975
    if( Header.JW_DATA_VERSION >= 420 ){
 
976
        int n1;
 
977
        for( int n=0; n<=32; n++){   //  線種パターン
 
978
            n1 = n + SXLTP_EXT;   //線種番号のオフセット = +30
 
979
            dw = Header.m_SxfLtp.m_alLType[n1];
 
980
            *ofs << dw;
 
981
            dw = Header.m_SxfLtp.m_anTokushuSenUintDot[n1];
 
982
            *ofs << dw;
 
983
            dw = Header.m_SxfLtp.m_anTokushuSenPich[n1];
 
984
            *ofs << dw;
 
985
            dw = Header.m_SxfLtp.m_anPrtTokushuSenPich[n1];
 
986
            *ofs << dw;
 
987
        }
 
988
        for( int n=0; n<=32; n++){   //  線種パラメータ
 
989
            WriteString(Header.m_SxfLtp.m_astrUDLTypeName[n]);
 
990
            dw = Header.m_SxfLtp.m_anUDLTypeSegment[n];
 
991
            *ofs << dw;
 
992
            for(int j=1; j<=10; j++){
 
993
                db = Header.m_SxfLtp.m_aadUDLTypePitch[n][j];
 
994
                *ofs << db;
 
995
            }
 
996
        }
 
997
    }
 
998
    //文字種1から10までの文字幅、高さ、間隔、色番号
 
999
    for(int i = 1; i <= 10; i++ )
 
1000
    {
 
1001
        db = Header.m_Moji[i].m_adMojiX;
 
1002
        *ofs << db;
 
1003
        db = Header.m_Moji[i].m_adMojiY;
 
1004
        *ofs << db;
 
1005
        db = Header.m_Moji[i].m_adMojiD;
 
1006
        *ofs << db;
 
1007
        dw = Header.m_Moji[i].m_anMojiCol;
 
1008
        *ofs << dw;
 
1009
    }
 
1010
    //書込み文字の文字幅、高さ、間隔、色番号、文字番号
 
1011
    db = Header.m_dMojiSizeX;
 
1012
    *ofs << db;
 
1013
    //
 
1014
    db = Header.m_dMojiSizeY;
 
1015
    *ofs << db;
 
1016
    //
 
1017
    db = Header.m_dMojiKankaku;
 
1018
    *ofs << db;
 
1019
    //
 
1020
    dw = Header.m_nMojiColor;
 
1021
    *ofs << dw;
 
1022
    //
 
1023
    dw = Header.m_nMojiShu;
 
1024
    *ofs << dw;
 
1025
    //文字位置整理の行間、文字数
 
1026
    db = Header.m_dMojiSeiriGyouKan;
 
1027
    *ofs << db;
 
1028
    //
 
1029
    db = Header.m_dMojiSeiriSuu;
 
1030
    *ofs << db;
 
1031
    //文字基準点のずれ位置使用のフラグ
 
1032
    dw = Header.m_nMojiKijunZureOn;
 
1033
    *ofs << dw;
 
1034
    //文字基準点の横方向のずれ位置左、中、右
 
1035
    db = Header.m_adMojiKijunZureX[0];
 
1036
    *ofs << db;
 
1037
    //
 
1038
    db = Header.m_adMojiKijunZureX[1];
 
1039
    *ofs << db;
 
1040
    //
 
1041
    db = Header.m_adMojiKijunZureX[2];
 
1042
    *ofs << db;
 
1043
    //文字基準点の縦方向のずれ位置下、中、上
 
1044
    db = Header.m_adMojiKijunZureY[0];
 
1045
    *ofs << db;
 
1046
    //
 
1047
    db = Header.m_adMojiKijunZureY[1];
 
1048
    *ofs << db;
 
1049
    //
 
1050
    db = Header.m_adMojiKijunZureY[2];
 
1051
    *ofs << db;
 
1052
 
 
1053
    return true;
 
1054
}
 
1055
 
 
1056
//データファイル読み込み
 
1057
BOOL JWWDocument::Read()
 
1058
{
 
1059
    if(!ifs)
 
1060
        return false;
 
1061
 
 
1062
    DWORD dw;
 
1063
//    DOUBLE db;
 
1064
    string s, t;
 
1065
    WORD wd;
 
1066
//    BYTE bt;
 
1067
    int i,j/*,k*/;
 
1068
 
 
1069
    BOOL ListFlag;
 
1070
    int ListCount;
 
1071
    int ListLength;
 
1072
    CDataSen    DSen;
 
1073
    CDataEnko   DEnko;
 
1074
    CDataTen    DTen;
 
1075
    CDataMoji   DMoji;
 
1076
    CDataSolid  DSolid;
 
1077
    CDataSunpou DSunpou;
 
1078
    CDataBlock  DBlock;
 
1079
    CDataList   DList;
 
1080
 
 
1081
    pBlockList->Init();
 
1082
    ListFlag = false;
 
1083
    ListLength = 0;
 
1084
    ListCount = 0;
 
1085
    if(!ReadHeader())
 
1086
        return false;
 
1087
    SenCount = 0;
 
1088
    EnkoCount = 0;
 
1089
    TenCount = 0;
 
1090
    MojiCount = 0;
 
1091
    SolidCount = 0;
 
1092
    BlockCount = 0;
 
1093
    SunpouCount = 0;
 
1094
 
 
1095
    //バージョン毎にデータ読み書きを変える
 
1096
    DSen.SetVersion(Header.JW_DATA_VERSION);
 
1097
    DEnko.SetVersion(Header.JW_DATA_VERSION);
 
1098
    DTen.SetVersion(Header.JW_DATA_VERSION);
 
1099
    DMoji.SetVersion(Header.JW_DATA_VERSION);
 
1100
    DSolid.SetVersion(Header.JW_DATA_VERSION);
 
1101
    DSunpou.SetVersion(Header.JW_DATA_VERSION);
 
1102
    DBlock.SetVersion(Header.JW_DATA_VERSION);
 
1103
 
 
1104
    *ifs >> wd;
 
1105
    if( wd == 0xFFFF )
 
1106
    {
 
1107
        *ifs >> dw;
 
1108
        j = dw;
 
1109
    } else
 
1110
        j = wd;
 
1111
 
 
1112
    i = 1;
 
1113
 
 
1114
    while( !ifs->eof() )
 
1115
    {
 
1116
        *ifs >> wd;
 
1117
        switch(wd){
 
1118
        case    0x0000:
 
1119
            continue;//goto exitloop;
 
1120
            break;
 
1121
        case    0xFFFF:
 
1122
            {
 
1123
                *ifs >> wd;
 
1124
                objCode = wd;
 
1125
                *ifs >> wd;
 
1126
                s = ReadData(wd);
 
1127
                pList->AddItem(i,s);
 
1128
                j = i;
 
1129
                i++;
 
1130
            }
 
1131
            break;
 
1132
        case    0xFF7F:
 
1133
             {
 
1134
                *ifs >> dw;
 
1135
                j = dw & 0x7FFFFFFF;
 
1136
            }
 
1137
            break;
 
1138
        case    0x7FFF:
 
1139
            {
 
1140
                *ifs >> dw;
 
1141
                j = dw & 0x7FFFFFFF;
 
1142
            }
 
1143
            break;
 
1144
        default:
 
1145
            {
 
1146
                if(wd & 0x8000)
 
1147
                    j = wd & 0x7FFF;
 
1148
                else
 
1149
                    j = 0;
 
1150
            }
 
1151
        }
 
1152
        s = pList->GetNoByItem(j).CDataString;
 
1153
#ifdef  DATA_DUMP
 
1154
cout << s << endl;
 
1155
#endif
 
1156
        if( ListCount == ListLength )
 
1157
            ListFlag = false;
 
1158
        if(s == "CDataList")
 
1159
        {
 
1160
            ListFlag = true;
 
1161
            ListCount = 0;
 
1162
            DList.Serialize(*ifs);
 
1163
#ifdef  DATA_DUMP
 
1164
cout << DList;
 
1165
#endif
 
1166
            pBlockList->AddBlockList(DList);
 
1167
            ListLength = DList.Count;
 
1168
        }
 
1169
        if( s == "CDataSen" )
 
1170
        {
 
1171
            DSen.Serialize(*ifs);
 
1172
#ifdef  DATA_DUMP
 
1173
cout << DSen;
 
1174
#endif
 
1175
            if( ListFlag )
 
1176
            {
 
1177
                pBlockList->AddDataListSen(DSen);
 
1178
                ListCount++;
 
1179
            } else
 
1180
            {
 
1181
                vSen.push_back(DSen);
 
1182
                SenCount++;
 
1183
            }
 
1184
        }
 
1185
        if( s == "CDataEnko")
 
1186
        {
 
1187
            DEnko.Serialize(*ifs);
 
1188
#ifdef  DATA_DUMP
 
1189
cout << DEnko;
 
1190
#endif
 
1191
            if( ListFlag )
 
1192
            {
 
1193
                pBlockList->AddDataListEnko(DEnko);
 
1194
                ListCount++;
 
1195
            }
 
1196
            else
 
1197
            {
 
1198
                vEnko.push_back(DEnko);
 
1199
                EnkoCount++;
 
1200
            }
 
1201
        }
 
1202
        if( s == "CDataTen" )
 
1203
        {
 
1204
            DTen.Serialize(*ifs);
 
1205
#ifdef  DATA_DUMP
 
1206
cout << DTen;
 
1207
#endif
 
1208
            if( ListFlag )
 
1209
            {
 
1210
                pBlockList->AddDataListTen(DTen);
 
1211
                ListCount++;
 
1212
            } else
 
1213
            {
 
1214
                vTen.push_back(DTen);
 
1215
                TenCount++;
 
1216
            }
 
1217
        }
 
1218
        if( s == "CDataMoji" )
 
1219
        {
 
1220
            DMoji.Serialize(*ifs);
 
1221
#ifdef  DATA_DUMP
 
1222
cout << DMoji;
 
1223
#endif
 
1224
            if( ListFlag )
 
1225
            {
 
1226
                pBlockList->AddDataListMoji(DMoji);
 
1227
                ListCount++;
 
1228
            } else
 
1229
            {
 
1230
                vMoji.push_back(DMoji);
 
1231
                MojiCount++;
 
1232
            }
 
1233
        }
 
1234
        if( s == "CDataSolid" )
 
1235
        {
 
1236
            DSolid.Serialize(*ifs);
 
1237
#ifdef  DATA_DUMP
 
1238
cout << DSolid;
 
1239
#endif
 
1240
            if( ListFlag )
 
1241
            {
 
1242
                pBlockList->AddDataListSolid(DSolid);
 
1243
                ListCount++;
 
1244
            } else
 
1245
            {
 
1246
                vSolid.push_back(DSolid);
 
1247
                SolidCount++;
 
1248
            }
 
1249
        }
 
1250
        if( s == "CDataBlock" )
 
1251
        {
 
1252
            DBlock.Serialize(*ifs);
 
1253
#ifdef  DATA_DUMP
 
1254
cout << DBlock;
 
1255
#endif
 
1256
            if(ListFlag)
 
1257
            {
 
1258
                pBlockList->AddDataListBlock(DBlock);
 
1259
                ListCount++;
 
1260
            } else
 
1261
            {
 
1262
                vBlock.push_back(DBlock);
 
1263
                BlockCount++;
 
1264
            }
 
1265
        }
 
1266
        if( s == "CDataSunpou" )
 
1267
        {
 
1268
            DSunpou.Serialize(*ifs);
 
1269
#ifdef  DATA_DUMP
 
1270
cout << DSunpou;
 
1271
#endif
 
1272
            if( ListFlag )
 
1273
            {
 
1274
                pBlockList->AddDataListSunpou(DSunpou);
 
1275
                ListCount++;
 
1276
            } else
 
1277
            {
 
1278
                vSunpou.push_back(DSunpou);
 
1279
                SunpouCount++;
 
1280
            }
 
1281
        }
 
1282
        if( !s.empty() )
 
1283
            i++;
 
1284
        s = "";
 
1285
    }
 
1286
//exitloop:
 
1287
    return true;
 
1288
}
 
1289
 
 
1290
BOOL JWWDocument::SaveBich16(DWORD id)
 
1291
{
 
1292
    DWORD i=((id*2) | 0x0000ffff) >> 16;
 
1293
    if( i==0 )
 
1294
        return true;
 
1295
    return false;
 
1296
}
 
1297
 
 
1298
//線
 
1299
BOOL JWWDocument::SaveSen(CDataSen& DSen)
 
1300
{
 
1301
    WORD wd;
 
1302
//    DWORD dw;
 
1303
    string s;
 
1304
    if( SaveSenCount == 0 )
 
1305
    {
 
1306
        PSen=Mpoint;
 
1307
        Mpoint++;
 
1308
        wd = 0xFFFF;
 
1309
        *ofs << wd;
 
1310
        *ofs << objCode;
 
1311
        s="CDataSen";
 
1312
        wd=s.length();
 
1313
        *ofs << wd;
 
1314
        ofs->write(s.c_str(), wd);
 
1315
    }else
 
1316
    {
 
1317
        wd=PSen | 0x8000;
 
1318
        *ofs << wd;
 
1319
    }
 
1320
    DSen.Serialize(*ofs);
 
1321
    SaveSenCount++;
 
1322
    Mpoint++;
 
1323
    return true;
 
1324
}
 
1325
 
 
1326
// 円
 
1327
BOOL JWWDocument::SaveEnko(CDataEnko& DEnko)
 
1328
{
 
1329
    WORD wd;
 
1330
    DWORD dw;
 
1331
    string s;
 
1332
    if( SaveEnkoCount == 0 )
 
1333
    {
 
1334
        PEnko=Mpoint;
 
1335
        Mpoint++;
 
1336
        wd=0xFFFF;
 
1337
        *ofs << wd;
 
1338
        *ofs << objCode;
 
1339
        s="CDataEnko";
 
1340
        wd=s.length();
 
1341
        *ofs << wd;
 
1342
        ofs->write(s.c_str(), wd);
 
1343
    }else
 
1344
    {
 
1345
        if( SaveBich16(PEnko) )
 
1346
        {
 
1347
            wd=PEnko | 0x8000;
 
1348
            *ofs << wd;
 
1349
        }
 
1350
        else
 
1351
        {
 
1352
            wd= 0x7FFF;
 
1353
            dw=PEnko | 0x80000000;
 
1354
            *ofs << wd;
 
1355
            *ofs << dw;
 
1356
        }
 
1357
    }
 
1358
    DEnko.Serialize(*ofs);
 
1359
    SaveEnkoCount++;
 
1360
    Mpoint++;
 
1361
    return true;
 
1362
}
 
1363
 
 
1364
// 点
 
1365
BOOL JWWDocument::SaveTen(CDataTen& DTen)
 
1366
{
 
1367
    WORD wd;
 
1368
    DWORD dw;
 
1369
    string s;
 
1370
 
 
1371
    if( SaveTenCount == 0 )
 
1372
    {
 
1373
        PTen=Mpoint;
 
1374
        Mpoint++;
 
1375
        wd=0xFFFF;
 
1376
        *ofs << wd;
 
1377
        *ofs << objCode;
 
1378
        s="CDataTen";
 
1379
        wd=s.length();
 
1380
        *ofs << wd;
 
1381
        ofs->write(s.c_str(), wd);
 
1382
    }else
 
1383
    {
 
1384
        if( SaveBich16(PTen) )
 
1385
        {
 
1386
            wd=PTen | 0x8000;
 
1387
            *ofs << wd;
 
1388
        }
 
1389
        else
 
1390
        {
 
1391
            wd= 0x7FFF;
 
1392
            *ofs << wd;
 
1393
            dw=PTen | 0x80000000;
 
1394
            *ofs << dw;
 
1395
        }
 
1396
    }
 
1397
    DTen.Serialize(*ofs);
 
1398
    SaveTenCount++;
 
1399
    Mpoint++;
 
1400
    return true;
 
1401
 
 
1402
}
 
1403
 
 
1404
// 文字
 
1405
BOOL JWWDocument::SaveMoji(CDataMoji& DMoji)
 
1406
{
 
1407
    WORD wd;
 
1408
    DWORD dw;
 
1409
    string s;
 
1410
 
 
1411
    if( SaveMojiCount == 0 )
 
1412
    {
 
1413
        PMoji=Mpoint;
 
1414
        Mpoint++;
 
1415
        wd=0xFFFF;
 
1416
        *ofs << wd;
 
1417
        *ofs << objCode;
 
1418
        s="CDataMoji";
 
1419
        wd=s.length();
 
1420
        *ofs << wd;
 
1421
        ofs->write(s.c_str(), wd);
 
1422
    }else
 
1423
    {
 
1424
        if( SaveBich16(PMoji) )
 
1425
        {
 
1426
            wd=PMoji | 0x8000;
 
1427
            *ofs << wd;
 
1428
        }
 
1429
        else
 
1430
        {
 
1431
            wd= 0x7FFF;
 
1432
            dw=PMoji | 0x80000000;
 
1433
            *ofs << wd;
 
1434
            *ofs << dw;
 
1435
        }
 
1436
    }
 
1437
    DMoji.Serialize(*ofs);
 
1438
    SaveMojiCount++;
 
1439
    Mpoint++;
 
1440
    return true;
 
1441
}
 
1442
 
 
1443
// 寸法
 
1444
BOOL JWWDocument::SaveSunpou(CDataSunpou& DSunpou)
 
1445
{
 
1446
    WORD wd;
 
1447
    DWORD dw;
 
1448
    string s;
 
1449
 
 
1450
    if( SaveSunpouCount == 0 )
 
1451
    {
 
1452
        PSunpou=Mpoint;
 
1453
        Mpoint++;
 
1454
        wd=0xFFFF;
 
1455
        *ofs << wd;
 
1456
        *ofs << objCode;
 
1457
        s="CDataSunpou";
 
1458
        wd=s.length();
 
1459
        *ofs << wd;
 
1460
        ofs->write(s.c_str(), wd);
 
1461
    } else
 
1462
    {
 
1463
        if( SaveBich16(PSunpou) )
 
1464
        {
 
1465
            wd=PSunpou | 0x8000;
 
1466
            *ofs << wd;
 
1467
        }
 
1468
        else
 
1469
        {
 
1470
            wd= 0x7FFF;
 
1471
            dw=PSunpou | 0x80000000;
 
1472
            *ofs << wd;
 
1473
            *ofs << dw;
 
1474
        }
 
1475
    }
 
1476
    DSunpou.Serialize(*ofs);
 
1477
    SaveSunpouCount++;
 
1478
    Mpoint++;
 
1479
    return true;
 
1480
}
 
1481
 
 
1482
// ソリッド
 
1483
BOOL JWWDocument::SaveSolid(CDataSolid& DSolid)
 
1484
{
 
1485
    WORD wd;
 
1486
    DWORD dw;
 
1487
    string s;
 
1488
 
 
1489
    if( SaveSolidCount == 0 )
 
1490
    {
 
1491
        PSolid=Mpoint;
 
1492
        Mpoint++;
 
1493
        wd=0xFFFF;
 
1494
        *ofs << wd;
 
1495
        *ofs << objCode;
 
1496
        s="CDataSolid";
 
1497
        wd=s.length();
 
1498
        *ofs << wd;
 
1499
        ofs->write(s.c_str(), wd);
 
1500
    } else
 
1501
    {
 
1502
        if( SaveBich16(PSolid) )
 
1503
        {
 
1504
            wd=PSolid | 0x8000;
 
1505
            *ofs << wd;
 
1506
        }
 
1507
        else
 
1508
        {
 
1509
            wd= 0x7FFF;
 
1510
            dw=PSolid | 0x80000000;
 
1511
            *ofs << wd;
 
1512
            *ofs << dw;
 
1513
        }
 
1514
    }
 
1515
    DSolid.Serialize(*ofs);
 
1516
    SaveSolidCount++;
 
1517
    Mpoint++;
 
1518
    return true;
 
1519
}
 
1520
 
 
1521
// ブロック
 
1522
BOOL JWWDocument::SaveBlock(CDataBlock& DBlock)
 
1523
{
 
1524
    WORD wd;
 
1525
    DWORD dw;
 
1526
    string s;
 
1527
 
 
1528
    if( SaveBlockCount == 0 )
 
1529
    {
 
1530
        PBlock=Mpoint;
 
1531
        Mpoint++;
 
1532
        wd=0xFFFF;
 
1533
        *ofs << wd;
 
1534
        *ofs << objCode;
 
1535
        s="CDataBlock";
 
1536
        wd=s.length();
 
1537
        *ofs << wd;
 
1538
        ofs->write(s.c_str(), wd);
 
1539
    } else
 
1540
    {
 
1541
        if( SaveBich16(PBlock) )
 
1542
        {
 
1543
            wd=PBlock | 0x8000;
 
1544
            *ofs << wd;
 
1545
        }
 
1546
        else
 
1547
        {
 
1548
            wd= 0x7FFF;
 
1549
            dw=PBlock | 0x80000000;
 
1550
            *ofs << wd;
 
1551
            *ofs << dw;
 
1552
        }
 
1553
    }
 
1554
    DBlock.Serialize(*ofs);
 
1555
    SaveBlockCount++;
 
1556
    Mpoint++;
 
1557
    return true;
 
1558
}
 
1559
 
 
1560
// データリスト
 
1561
BOOL JWWDocument::SaveDataList(CDataList& DList)
 
1562
{
 
1563
    WORD wd;
 
1564
    DWORD dw;
 
1565
    string s;
 
1566
 
 
1567
    if( SaveDataListCount == 0 )
 
1568
    {
 
1569
        PList=Mpoint;
 
1570
        Mpoint++;
 
1571
        wd=0xFFFF;
 
1572
        *ofs << wd;
 
1573
        *ofs << objCode;
 
1574
        s="CDataList";
 
1575
        wd=s.length();
 
1576
        *ofs << wd;
 
1577
        ofs->write(s.c_str(), wd);
 
1578
    } else
 
1579
    {
 
1580
        if( SaveBich16(PList) )
 
1581
        {
 
1582
            wd=PList | 0x8000;
 
1583
            *ofs << wd;
 
1584
        }
 
1585
        else
 
1586
        {
 
1587
            wd= 0x7FFF;
 
1588
            dw=PList | 0x80000000;
 
1589
            *ofs << wd;
 
1590
            *ofs << dw;
 
1591
        }
 
1592
    }
 
1593
    DList.Serialize(*ofs);
 
1594
    SaveDataListCount++;
 
1595
    Mpoint++;
 
1596
    return true;
 
1597
}
 
1598
 
 
1599
//データファイル保存
 
1600
BOOL JWWDocument::Save()
 
1601
{
 
1602
    if(!ofs)
 
1603
        return false;
 
1604
    DWORD dw;
 
1605
    WORD wd;
 
1606
//    DOUBLE db;
 
1607
    string s;
 
1608
    SaveSenCount=0;
 
1609
    SaveEnkoCount=0;
 
1610
    SaveTenCount=0;
 
1611
    SaveMojiCount=0;
 
1612
    SaveSunpouCount=0;
 
1613
    SaveSolidCount=0;
 
1614
    SaveBlockCount=0;
 
1615
    SaveDataListCount=0;
 
1616
 
 
1617
    WriteHeader();
 
1618
    //データ出力
 
1619
    dw = vSen.size() + vEnko.size() + vTen.size() + vMoji.size() + vSunpou.size() + vSolid.size() + vBlock.size();// + 7;
 
1620
    if( SaveBich16(dw) )
 
1621
        ofs->write((char*)&dw,2);
 
1622
    else
 
1623
    {
 
1624
        wd= 0xFFFF;
 
1625
        *ofs << wd;
 
1626
        *ofs << dw;
 
1627
    }
 
1628
    Mpoint=1;
 
1629
    unsigned int i;
 
1630
    int j;
 
1631
    for( i=0 ; i < vSen.size(); i++ )
 
1632
        SaveSen(vSen[i]);
 
1633
    for( i=0 ; i < vEnko.size(); i++ )
 
1634
        SaveEnko(vEnko[i]);
 
1635
    for( i=0 ; i < vTen.size(); i++ )
 
1636
        SaveTen(vTen[i]);
 
1637
    for( i=0 ; i < vMoji.size(); i++ )
 
1638
        SaveMoji(vMoji[i]);
 
1639
    for( i=0 ; i < vSunpou.size(); i++ )
 
1640
        SaveSunpou(vSunpou[i]);
 
1641
    for( i=0 ; i < vSolid.size(); i++ )
 
1642
        SaveSolid(vSolid[i]);
 
1643
    for( i=0 ; i < vBlock.size(); i++)
 
1644
        SaveBlock(vBlock[i]);
 
1645
    dw=pBlockList->getBlockListCount();
 
1646
    *ofs << dw;
 
1647
    for( i=0; i < dw; i++ )
 
1648
    {
 
1649
        SaveDataList(pBlockList->GetBlockList(i));
 
1650
        int Count=pBlockList->GetDataListCount(i);
 
1651
        for( j=0 ; j < Count; j++)
 
1652
        {
 
1653
            switch(pBlockList->GetDataType(i,j))
 
1654
            {
 
1655
            case        Sen :
 
1656
                SaveSen(pBlockList->GetCDataSen(i,j));
 
1657
                break;
 
1658
            case        Enko:
 
1659
                SaveEnko(pBlockList->GetCDataEnko(i,j));
 
1660
                break;
 
1661
            case        Ten:
 
1662
                SaveTen(pBlockList->GetCDataTen(i,j));
 
1663
                break;
 
1664
            case        Moji:
 
1665
                SaveMoji(pBlockList->GetCDataMoji(i,j));
 
1666
                break;
 
1667
            case        Solid:
 
1668
                SaveSolid(pBlockList->GetCDataSolid(i,j));
 
1669
                break;
 
1670
            case        Sunpou:
 
1671
                SaveSunpou(pBlockList->GetCDataSunpou(i,j));
 
1672
                break;
 
1673
            case        Block:
 
1674
                SaveBlock(pBlockList->GetCDataBlock(i,j));
 
1675
                break;
 
1676
            }
 
1677
        }
 
1678
    }
 
1679
    return true;
 
1680
}
 
1681
 
 
1682
void JWWList::AddItem(int No, string& str)
 
1683
{
 
1684
    PNoList     nList = new NoList;
 
1685
    nList->CDataString = str;
 
1686
    nList->No = No;
 
1687
    FList.push_back(nList);
 
1688
}
 
1689
 
 
1690
JWWList::JWWList()
 
1691
{
 
1692
    string str = "";
 
1693
    //NULLデータ登録
 
1694
    AddItem(0, str);
 
1695
}
 
1696
 
 
1697
JWWList::~JWWList()
 
1698
{
 
1699
    for( unsigned int i=0; i < FList.size(); i++)
 
1700
        if(FList[i])
 
1701
            delete FList[i];
 
1702
    FList.clear();
 
1703
}
 
1704
 
 
1705
int JWWList::GetCount()
 
1706
{
 
1707
    return FList.size();
 
1708
}
 
1709
 
 
1710
NoList& JWWList::GetItem(int i)
 
1711
{
 
1712
    return *FList[i];
 
1713
}
 
1714
 
 
1715
 
 
1716
NoList& JWWList::GetNoByItem(int No)
 
1717
{
 
1718
//      vector<PNoList>::iterator   itr    = vect.begin();
 
1719
//      vector<PNoList>::iterator   itrEnd = vect.end();
 
1720
    for( unsigned int i=0; i < FList.size(); i++)
 
1721
    {
 
1722
        if(FList[i]->No == No){
 
1723
            return *FList[i];
 
1724
        }
 
1725
    }
 
1726
    return *FList[0];
 
1727
}
 
1728
 
 
1729
JWWBlockList::JWWBlockList()
 
1730
{
 
1731
}
 
1732
 
 
1733
JWWBlockList::~JWWBlockList()
 
1734
{
 
1735
    int sz = FBlockList.size();
 
1736
    for(int i=0; i < sz; i++)
 
1737
    {
 
1738
        if(FBlockList[i])
 
1739
            delete FBlockList[i];
 
1740
    }
 
1741
    FBlockList.clear();
 
1742
 
 
1743
/*
 
1744
    //2010-02-09  不要な削除
 
1745
    sz = FDataList.size();
 
1746
    for(int i=0; i < sz; i++)
 
1747
    {
 
1748
        if(FDataList[i])
 
1749
            delete FDataList[i];
 
1750
    }
 
1751
    FDataList.clear();
 
1752
 
 
1753
    FDataType.clear();
 
1754
*/
 
1755
}
 
1756
 
 
1757
CDataList& JWWBlockList::GetBlockList(unsigned int i)
 
1758
{
 
1759
    for(unsigned int k=0; k < FBlockList.size(); k++)
 
1760
        if(i == FBlockList[k]->m_n_Number)
 
1761
            return *(PCDataList)FBlockList[k];
 
1762
    return *PCDataList();
 
1763
}
 
1764
 
 
1765
int JWWBlockList::getBlockListCount()
 
1766
{
 
1767
    return FBlockList.size();
 
1768
}
 
1769
 
 
1770
CDataEnko& JWWBlockList::GetCDataEnko(int i, int j)
 
1771
{
 
1772
    if( GetCDataType(i,j) == Enko )
 
1773
        return *(PCDataEnko)GetData(i,j);
 
1774
    return *PCDataEnko();
 
1775
}
 
1776
 
 
1777
CDataMoji& JWWBlockList::GetCDataMoji(int i, int j)
 
1778
{
 
1779
    if( GetCDataType(i,j) == Moji )
 
1780
        return *(PCDataMoji)GetData(i,j);
 
1781
    return *PCDataMoji();
 
1782
}
 
1783
 
 
1784
CDataSen& JWWBlockList::GetCDataSen(int i, int j)
 
1785
{
 
1786
    if( GetCDataType(i,j) == Sen )
 
1787
        return *(PCDataSen)GetData(i,j);
 
1788
    return *PCDataSen();
 
1789
}
 
1790
 
 
1791
CDataSolid& JWWBlockList::GetCDataSolid(int i, int j)
 
1792
{
 
1793
    if( GetCDataType(i,j) == Solid )
 
1794
        return *(PCDataSolid)GetData(i,j);
 
1795
    return *PCDataSolid();
 
1796
}
 
1797
 
 
1798
CDataSunpou& JWWBlockList::GetCDataSunpou(int i, int j)
 
1799
{
 
1800
    if( GetCDataType(i,j) == Sunpou )
 
1801
        return *(PCDataSunpou)GetData(i,j);
 
1802
    return *PCDataSunpou();
 
1803
}
 
1804
 
 
1805
CDataTen& JWWBlockList::GetCDataTen(int i, int j)
 
1806
{
 
1807
    if( GetCDataType(i,j) == Ten )
 
1808
        return *(PCDataTen)GetData(i,j);
 
1809
    return *PCDataTen();
 
1810
}
 
1811
 
 
1812
CDataType JWWBlockList::GetCDataType(int i, int j)
 
1813
{
 
1814
    return GetDataType(i,j);
 
1815
}
 
1816
 
 
1817
void* JWWBlockList::GetData(unsigned int i, int j)
 
1818
{
 
1819
    int l = 0;
 
1820
    for( unsigned int k=0; k < FBlockList.size(); k++ )
 
1821
    {
 
1822
        if( i == PCDataList(FBlockList[k])->m_nNumber )
 
1823
            return FDataList[l+j];
 
1824
        l=l + PCDataList(FBlockList[k])->Count;
 
1825
    }
 
1826
    return (void *)NULL;
 
1827
}
 
1828
 
 
1829
int JWWBlockList::GetDataListCount(unsigned int i)
 
1830
{
 
1831
    for(unsigned int k=0; k < FBlockList.size(); k++)
 
1832
    {
 
1833
        if( i == PCDataList(FBlockList[k])->m_nNumber )
 
1834
            return PCDataList(FBlockList[k])->Count;
 
1835
    }
 
1836
    return 0;
 
1837
}
 
1838
 
 
1839
CDataType JWWBlockList::GetDataType(unsigned int i, int j)
 
1840
{
 
1841
    int l = 0;
 
1842
    for( unsigned int k=0; k < FBlockList.size(); k++ )
 
1843
    {
 
1844
        if( i == PCDataList(FBlockList[k])->m_nNumber )
 
1845
            return FDataType[l+j];
 
1846
        l=l + PCDataList(FBlockList[k])->Count;
 
1847
    }
 
1848
    return Sen;
 
1849
}
 
1850
 
 
1851
void JWWBlockList::AddBlockList(CDataList& CData)
 
1852
{
 
1853
    PCDataList data = new CDataList;
 
1854
    *data = CData;
 
1855
    FBlockList.push_back((PCDataBlock)data);
 
1856
}
 
1857
 
 
1858
void JWWBlockList::AddDataListEnko(CDataEnko& D)
 
1859
{
 
1860
    PCDataEnko data = new CDataEnko;
 
1861
    *data = D;
 
1862
    FDataType.push_back(Enko);
 
1863
    FDataList.push_back((PCDataList)data);
 
1864
}
 
1865
 
 
1866
void JWWBlockList::AddDataListMoji(CDataMoji& D)
 
1867
{
 
1868
    PCDataMoji data = new CDataMoji;
 
1869
    *data = D;
 
1870
    FDataType.push_back(Moji);
 
1871
    FDataList.push_back((PCDataList)data);
 
1872
}
 
1873
 
 
1874
void JWWBlockList::AddDataListSen(CDataSen& D)
 
1875
{
 
1876
    PCDataSen data = new CDataSen;
 
1877
    *data = D;
 
1878
    FDataType.push_back(Sen);
 
1879
    FDataList.push_back((PCDataList)data);
 
1880
}
 
1881
 
 
1882
void JWWBlockList::AddDataListSolid(CDataSolid& D)
 
1883
{
 
1884
    PCDataSolid data = new CDataSolid;
 
1885
    *data = D;
 
1886
    FDataType.push_back(Solid);
 
1887
    FDataList.push_back((PCDataList)data);
 
1888
}
 
1889
 
 
1890
void JWWBlockList::AddDataListSunpou(CDataSunpou& D)
 
1891
{
 
1892
    PCDataSunpou data = new CDataSunpou;
 
1893
    *data = D;
 
1894
    FDataType.push_back(Sunpou);
 
1895
    FDataList.push_back((PCDataList)data);
 
1896
}
 
1897
 
 
1898
void JWWBlockList::AddDataListTen(CDataTen& D)
 
1899
{
 
1900
    PCDataTen data = new CDataTen;
 
1901
    *data = D;
 
1902
    FDataType.push_back(Ten);
 
1903
    FDataList.push_back((PCDataList)data);
 
1904
}
 
1905
 
 
1906
void JWWBlockList::Init()
 
1907
{
 
1908
    for(unsigned int i=0; i < FBlockList.size(); i++)
 
1909
    {
 
1910
        if(FBlockList[i])
 
1911
            delete FBlockList[i];
 
1912
    }
 
1913
    FBlockList.clear();
 
1914
 
 
1915
    for(unsigned int i=0; i < FDataList.size(); i++)
 
1916
    {
 
1917
        if(FDataList[i])
 
1918
            delete FDataList[i];
 
1919
    }
 
1920
    FDataList.clear();
 
1921
    FDataType.clear();
 
1922
}
 
1923
 
 
1924
void JWWBlockList::AddDataListBlock(CDataBlock& D)
 
1925
{
 
1926
    PCDataBlock data = new CDataBlock;
 
1927
    *data = D;
 
1928
    FDataType.push_back(Block);
 
1929
    FDataList.push_back((PCDataList)data);
 
1930
}
 
1931
 
 
1932
CDataBlock& JWWBlockList::GetCDataBlock(int i, int j)
 
1933
{
 
1934
    if( GetCDataType(i,j) == Block )
 
1935
        return *PCDataBlock(GetData(i,j));
 
1936
    return *PCDataBlock();
 
1937
}