← Back to branch summary

~cern-kicad/kicad/kicad-pns-tom

« back to all changes in this revision

Viewing changes to common/page_layout/page_layout_reader.cpp

  • Committer: Maciej Suminski
  • Date: 2013-08-02 13:57:24 UTC
  • mfrom: (4024.1.238 kicad)
  • mto: This revision was merged to the branch mainline in revision 4221.
  • Revision ID: maciej.suminski@cern.ch-20130802135724-gix6orezshkukodv
Upstream merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/page_layout/page_layout_reader.cpp
 
1
/**
 
2
 * @file page_layout_reader.cpp
 
3
 * @brief read an S expression of description of graphic items and texts
 
4
 * to build a title block and page layout
 
5
 */
 
6
 
 
7
/*
 
8
 * This program source code file is part of KiCad, a free EDA CAD application.
 
9
 *
 
10
 * Copyright (C) 1992-2013 Jean-Pierre Charras <jp.charras at wanadoo.fr>.
 
11
 * Copyright (C) 1992-2013 KiCad Developers, see change_log.txt for contributors.
 
12
 *
 
13
 *
 
14
 * This program is free software; you can redistribute it and/or
 
15
 * modify it under the terms of the GNU General Public License
 
16
 * as published by the Free Software Foundation; either version 2
 
17
 * of the License, or (at your option) any later version.
 
18
 *
 
19
 * This program is distributed in the hope that it will be useful,
 
20
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
22
 * GNU General Public License for more details.
 
23
 *
 
24
 * You should have received a copy of the GNU General Public License
 
25
 * along with this program; if not, you may find one here:
 
26
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 
27
 * or you may search the http://www.gnu.org website for the version 2 license,
 
28
 * or you may write to the Free Software Foundation, Inc.,
 
29
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 
30
 */
 
31
 
 
32
#include <fctsys.h>
 
33
#include <base_struct.h>
 
34
#include <worksheet.h>
 
35
#include <worksheet_shape_builder.h>
 
36
#include <class_worksheet_dataitem.h>
 
37
#include <page_layout_reader_lexer.h>
 
38
 
 
39
 
 
40
using namespace TB_READER_T;
 
41
 
 
42
/**
 
43
 * Class PAGE_LAYOUT_READER_PARSER
 
44
 * holds data and functions pertinent to parsing a S-expression file
 
45
 * for a WORKSHEET_LAYOUT.
 
46
 */
 
47
class PAGE_LAYOUT_READER_PARSER : public PAGE_LAYOUT_READER_LEXER
 
48
{
 
49
public:
 
50
    PAGE_LAYOUT_READER_PARSER( const char* aLine, const wxString& aSource );
 
51
    void Parse( WORKSHEET_LAYOUT* aLayout )
 
52
                throw( PARSE_ERROR, IO_ERROR );
 
53
 
 
54
private:
 
55
 
 
56
    /**
 
57
     * Function parseInt
 
58
     * parses an integer and constrains it between two values.
 
59
     * @param aMin is the smallest return value.
 
60
     * @param aMax is the largest return value.
 
61
     * @return int - the parsed integer.
 
62
     */
 
63
    int parseInt( int aMin, int aMax );
 
64
 
 
65
    /**
 
66
     * Function parseDouble
 
67
     * parses a double
 
68
     * @return double - the parsed double.
 
69
     */
 
70
    double parseDouble();
 
71
 
 
72
    void parseSetup( WORKSHEET_LAYOUT* aLayout ) throw( IO_ERROR, PARSE_ERROR );
 
73
    void parseGraphic( WORKSHEET_DATAITEM * aItem ) throw( IO_ERROR, PARSE_ERROR );
 
74
    void parseText( WORKSHEET_DATAITEM_TEXT * aItem ) throw( IO_ERROR, PARSE_ERROR );
 
75
    void parsePolygon( WORKSHEET_DATAITEM_POLYPOLYGON * aItem )
 
76
        throw( IO_ERROR, PARSE_ERROR );
 
77
    void parsePolyOutline( WORKSHEET_DATAITEM_POLYPOLYGON * aItem )
 
78
        throw( IO_ERROR, PARSE_ERROR );
 
79
    void parseCoordinate( POINT_COORD& aCoord) throw( IO_ERROR, PARSE_ERROR );
 
80
    void readOption( WORKSHEET_DATAITEM * aItem ) throw( IO_ERROR, PARSE_ERROR );
 
81
};
 
82
 
 
83
// PCB_PLOT_PARAMS_PARSER
 
84
 
 
85
PAGE_LAYOUT_READER_PARSER::PAGE_LAYOUT_READER_PARSER( const char* aLine, const wxString& aSource ) :
 
86
    PAGE_LAYOUT_READER_LEXER( aLine, aSource )
 
87
{
 
88
}
 
89
 
 
90
 
 
91
void PAGE_LAYOUT_READER_PARSER::Parse( WORKSHEET_LAYOUT* aLayout )
 
92
                             throw( PARSE_ERROR, IO_ERROR )
 
93
{
 
94
    T token;
 
95
    WORKSHEET_DATAITEM * item;
 
96
 
 
97
    LOCALE_IO toggle;
 
98
 
 
99
    while( ( token = NextTok() ) != T_RIGHT )
 
100
    {
 
101
        if( token == T_EOF)
 
102
           break;
 
103
 
 
104
        if( token == T_LEFT )
 
105
            token = NextTok();
 
106
 
 
107
        if( token == T_page_layout )
 
108
            continue;
 
109
 
 
110
        switch( token )
 
111
        {
 
112
        case T_setup:   // Defines default values for graphic items
 
113
            parseSetup( aLayout );
 
114
            break;
 
115
 
 
116
        case T_line:
 
117
            item = new WORKSHEET_DATAITEM( WORKSHEET_DATAITEM::WS_SEGMENT );
 
118
            parseGraphic( item );
 
119
            aLayout->Append( item );
 
120
            break;
 
121
 
 
122
        case T_rect:
 
123
            item = new WORKSHEET_DATAITEM( WORKSHEET_DATAITEM::WS_RECT );
 
124
            parseGraphic( item );
 
125
            aLayout->Append( item );
 
126
            break;
 
127
 
 
128
        case T_polygon:
 
129
            item = new WORKSHEET_DATAITEM_POLYPOLYGON();
 
130
            parsePolygon(  (WORKSHEET_DATAITEM_POLYPOLYGON*) item );
 
131
            aLayout->Append( item );
 
132
            break;
 
133
 
 
134
        case T_tbtext:
 
135
            NeedSYMBOLorNUMBER();
 
136
            item = new WORKSHEET_DATAITEM_TEXT( FromUTF8() );
 
137
            parseText( (WORKSHEET_DATAITEM_TEXT*) item );
 
138
            aLayout->Append( item );
 
139
            break;
 
140
 
 
141
        default:
 
142
            Unexpected( CurText() );
 
143
            break;
 
144
        }
 
145
    }
 
146
}
 
147
 
 
148
void PAGE_LAYOUT_READER_PARSER::parseSetup( WORKSHEET_LAYOUT* aLayout )
 
149
    throw( IO_ERROR, PARSE_ERROR )
 
150
{
 
151
    T token;
 
152
    while( ( token = NextTok() ) != T_RIGHT )
 
153
    {
 
154
        if( token == T_EOF)
 
155
           break;
 
156
 
 
157
        switch( token )
 
158
        {
 
159
        case T_LEFT:
 
160
            break;
 
161
 
 
162
        case T_linewidth:
 
163
            WORKSHEET_DATAITEM::m_DefaultLineWidth = parseDouble();
 
164
            NeedRIGHT();
 
165
            break;
 
166
 
 
167
        case T_textsize:
 
168
            WORKSHEET_DATAITEM::m_DefaultTextSize.x = parseDouble();
 
169
            WORKSHEET_DATAITEM::m_DefaultTextSize.y = parseDouble();
 
170
            NeedRIGHT();
 
171
            break;
 
172
 
 
173
        case T_textlinewidth:
 
174
            WORKSHEET_DATAITEM::m_DefaultTextThickness = parseDouble();
 
175
            NeedRIGHT();
 
176
            break;
 
177
 
 
178
        case T_left_margin:
 
179
            aLayout->SetLeftMargin( parseDouble() );
 
180
            NeedRIGHT();
 
181
            break;
 
182
 
 
183
        case T_right_margin:
 
184
            aLayout->SetRightMargin( parseDouble() );
 
185
            NeedRIGHT();
 
186
            break;
 
187
 
 
188
        case T_top_margin:
 
189
            aLayout->SetTopMargin( parseDouble() );
 
190
            NeedRIGHT();
 
191
            break;
 
192
 
 
193
        case T_bottom_margin:
 
194
            aLayout->SetBottomMargin( parseDouble() );
 
195
            NeedRIGHT();
 
196
            break;
 
197
 
 
198
        default:
 
199
            Unexpected( CurText() );
 
200
            break;
 
201
        }
 
202
    }
 
203
}
 
204
 
 
205
void PAGE_LAYOUT_READER_PARSER::parsePolygon( WORKSHEET_DATAITEM_POLYPOLYGON * aItem )
 
206
    throw( IO_ERROR, PARSE_ERROR )
 
207
{
 
208
    T token;
 
209
 
 
210
    while( ( token = NextTok() ) != T_RIGHT )
 
211
    {
 
212
        if( token == T_EOF)
 
213
           break;
 
214
 
 
215
        if( token == T_LEFT )
 
216
            token = NextTok();
 
217
 
 
218
        switch( token )
 
219
        {
 
220
        case T_comment:
 
221
            NeedSYMBOLorNUMBER();
 
222
            aItem->m_Info =  FromUTF8();
 
223
            NeedRIGHT();
 
224
            break;
 
225
 
 
226
        case T_pos:
 
227
            parseCoordinate( aItem->m_Pos );
 
228
            break;
 
229
 
 
230
        case T_name:
 
231
            NeedSYMBOLorNUMBER();
 
232
            aItem->m_Name =  FromUTF8();
 
233
            NeedRIGHT();
 
234
            break;
 
235
 
 
236
        case T_option:
 
237
            readOption( aItem );
 
238
            break;
 
239
 
 
240
        case T_pts:
 
241
            parsePolyOutline( aItem );
 
242
            aItem->CloseContour();
 
243
            break;
 
244
 
 
245
        case T_rotate:
 
246
            aItem->m_Orient = parseDouble();
 
247
            NeedRIGHT();
 
248
            break;
 
249
 
 
250
        case T_repeat:
 
251
            aItem->m_RepeatCount = parseInt( -1, 100 );
 
252
            NeedRIGHT();
 
253
            break;
 
254
 
 
255
        case T_incrx:
 
256
            aItem->m_IncrementVector.x = parseDouble();
 
257
            NeedRIGHT();
 
258
            break;
 
259
 
 
260
        case T_incry:
 
261
            aItem->m_IncrementVector.y = parseDouble();
 
262
            NeedRIGHT();
 
263
            break;
 
264
 
 
265
        case T_linewidth:
 
266
            aItem->m_LineWidth = parseDouble();
 
267
            NeedRIGHT();
 
268
            break;
 
269
 
 
270
        default:
 
271
            Unexpected( CurText() );
 
272
            break;
 
273
        }
 
274
    }
 
275
 
 
276
    aItem->SetBoundingBox();
 
277
}
 
278
 
 
279
void PAGE_LAYOUT_READER_PARSER::parsePolyOutline( WORKSHEET_DATAITEM_POLYPOLYGON * aItem )
 
280
    throw( IO_ERROR, PARSE_ERROR )
 
281
{
 
282
    DPOINT corner;
 
283
    T token;
 
284
 
 
285
    while( ( token = NextTok() ) != T_RIGHT )
 
286
    {
 
287
        if( token == T_EOF)
 
288
           break;
 
289
 
 
290
        if( token == T_LEFT )
 
291
            token = NextTok();
 
292
 
 
293
        switch( token )
 
294
        {
 
295
        case T_xy:
 
296
            corner.x = parseDouble();
 
297
            corner.y = parseDouble();
 
298
            aItem->AppendCorner( corner );
 
299
            NeedRIGHT();
 
300
            break;
 
301
 
 
302
        default:
 
303
            Unexpected( CurText() );
 
304
            break;
 
305
        }
 
306
    }
 
307
}
 
308
 
 
309
void PAGE_LAYOUT_READER_PARSER::readOption( WORKSHEET_DATAITEM * aItem )
 
310
    throw( IO_ERROR, PARSE_ERROR )
 
311
{
 
312
    T token;
 
313
 
 
314
    while( ( token = NextTok() ) != T_RIGHT )
 
315
    {
 
316
        if( token == T_EOF)
 
317
           break;
 
318
 
 
319
        switch( token )
 
320
        {
 
321
        case T_page1only:
 
322
            aItem->SetPage1Option( 1 );
 
323
            break;
 
324
 
 
325
        case T_notonpage1:
 
326
            aItem->SetPage1Option( -1 );
 
327
            break;
 
328
 
 
329
        default:
 
330
            Unexpected( CurText() );
 
331
            break;
 
332
        }
 
333
    }
 
334
}
 
335
 
 
336
 
 
337
void PAGE_LAYOUT_READER_PARSER::parseGraphic( WORKSHEET_DATAITEM * aItem )
 
338
    throw( IO_ERROR, PARSE_ERROR )
 
339
{
 
340
    T token;
 
341
 
 
342
    while( ( token = NextTok() ) != T_RIGHT )
 
343
    {
 
344
        if( token == T_EOF)
 
345
           break;
 
346
 
 
347
        if( token == T_LEFT )
 
348
            token = NextTok();
 
349
 
 
350
        switch( token )
 
351
        {
 
352
        case T_comment:
 
353
            NeedSYMBOLorNUMBER();
 
354
            aItem->m_Info =  FromUTF8();
 
355
            NeedRIGHT();
 
356
            break;
 
357
 
 
358
        case T_option:
 
359
            readOption( aItem );
 
360
            break;
 
361
 
 
362
        case T_name:
 
363
            NeedSYMBOLorNUMBER();
 
364
            aItem->m_Name = FromUTF8();
 
365
            NeedRIGHT();
 
366
            break;
 
367
 
 
368
        case T_start:
 
369
            parseCoordinate( aItem->m_Pos );
 
370
            break;
 
371
 
 
372
        case T_end:
 
373
            parseCoordinate( aItem->m_End );
 
374
            break;
 
375
 
 
376
        case T_repeat:
 
377
            aItem->m_RepeatCount = parseInt( -1, 100 );
 
378
            NeedRIGHT();
 
379
            break;
 
380
 
 
381
        case T_incrx:
 
382
            aItem->m_IncrementVector.x = parseDouble();
 
383
            NeedRIGHT();
 
384
            break;
 
385
 
 
386
        case T_incry:
 
387
            aItem->m_IncrementVector.y = parseDouble();
 
388
            NeedRIGHT();
 
389
            break;
 
390
 
 
391
        case T_linewidth:
 
392
            aItem->m_LineWidth = parseDouble();
 
393
            NeedRIGHT();
 
394
            break;
 
395
 
 
396
        default:
 
397
            Unexpected( CurText() );
 
398
            break;
 
399
        }
 
400
    }
 
401
}
 
402
 
 
403
 
 
404
void PAGE_LAYOUT_READER_PARSER::parseText( WORKSHEET_DATAITEM_TEXT* aItem )
 
405
    throw( IO_ERROR, PARSE_ERROR )
 
406
{
 
407
    T token;
 
408
 
 
409
    while( ( token = NextTok() ) != T_RIGHT )
 
410
    {
 
411
        if( token == T_EOF)
 
412
           break;
 
413
 
 
414
        if( token == T_LEFT )
 
415
            token = NextTok();
 
416
 
 
417
        switch( token )
 
418
        {
 
419
        case T_comment:
 
420
            NeedSYMBOLorNUMBER();
 
421
            aItem->m_Info =  FromUTF8();
 
422
            NeedRIGHT();
 
423
            break;
 
424
 
 
425
        case T_option:
 
426
            readOption( aItem );
 
427
            break;
 
428
 
 
429
        case T_name:
 
430
            NeedSYMBOLorNUMBER();
 
431
            aItem->m_Name =  FromUTF8();
 
432
            NeedRIGHT();
 
433
            break;
 
434
 
 
435
        case T_pos:
 
436
            parseCoordinate( aItem->m_Pos );
 
437
            break;
 
438
 
 
439
        case T_repeat:
 
440
            aItem->m_RepeatCount = parseInt( -1, 100 );
 
441
            NeedRIGHT();
 
442
            break;
 
443
 
 
444
        case T_incrx:
 
445
            aItem->m_IncrementVector.x = parseDouble();
 
446
            NeedRIGHT();
 
447
            break;
 
448
 
 
449
        case T_incry:
 
450
            aItem->m_IncrementVector.y = parseDouble();
 
451
            NeedRIGHT();
 
452
            break;
 
453
 
 
454
        case T_incrlabel:
 
455
            aItem->m_IncrementLabel = parseInt(INT_MIN, INT_MAX);
 
456
            NeedRIGHT();
 
457
            break;
 
458
 
 
459
        case T_maxlen:
 
460
            aItem->m_BoundingBoxSize.x = parseDouble();
 
461
            NeedRIGHT();
 
462
            break;
 
463
 
 
464
        case T_maxheight:
 
465
            aItem->m_BoundingBoxSize.y = parseDouble();
 
466
            NeedRIGHT();
 
467
            break;
 
468
 
 
469
        case T_font:
 
470
            while( ( token = NextTok() ) != T_RIGHT )
 
471
            {
 
472
                if( token == T_EOF)
 
473
                   break;
 
474
 
 
475
                switch( token )
 
476
                {
 
477
                case T_LEFT:
 
478
                    break;
 
479
 
 
480
                case T_bold:
 
481
                    aItem->SetBold( true );
 
482
                    break;
 
483
 
 
484
                case T_italic:
 
485
                    aItem->SetItalic( true );
 
486
                    break;
 
487
 
 
488
                case T_size:
 
489
                    aItem->m_TextSize.x = parseDouble();
 
490
                    aItem->m_TextSize.y = parseDouble();
 
491
                    NeedRIGHT();
 
492
                    break;
 
493
 
 
494
                case T_linewidth:
 
495
                    aItem->m_LineWidth = parseDouble();
 
496
                    NeedRIGHT();
 
497
                    break;
 
498
 
 
499
                default:
 
500
                    Unexpected( CurText() );
 
501
                    break;
 
502
                }
 
503
            }
 
504
            break;
 
505
 
 
506
        case T_justify:
 
507
            while( ( token = NextTok() ) != T_RIGHT )
 
508
            {
 
509
                if( token == T_EOF)
 
510
                   break;
 
511
 
 
512
                switch( token )
 
513
                {
 
514
                case T_center:
 
515
                    aItem->m_Hjustify = GR_TEXT_HJUSTIFY_CENTER;
 
516
                    aItem->m_Vjustify = GR_TEXT_VJUSTIFY_CENTER;
 
517
                    break;
 
518
 
 
519
                case T_left:
 
520
                    aItem->m_Hjustify = GR_TEXT_HJUSTIFY_LEFT;
 
521
                    break;
 
522
 
 
523
                case T_right:
 
524
                    aItem->m_Hjustify = GR_TEXT_HJUSTIFY_RIGHT;
 
525
                    break;
 
526
 
 
527
                case T_top:
 
528
                    aItem->m_Vjustify = GR_TEXT_VJUSTIFY_TOP;
 
529
                    break;
 
530
 
 
531
                case T_bottom:
 
532
                    aItem->m_Vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
 
533
                    break;
 
534
 
 
535
                default:
 
536
                    Unexpected( CurText() );
 
537
                    break;
 
538
                }
 
539
            }
 
540
            break;
 
541
 
 
542
        case T_rotate:
 
543
            aItem->m_Orient = parseDouble();
 
544
            NeedRIGHT();
 
545
            break;
 
546
 
 
547
        default:
 
548
            Unexpected( CurText() );
 
549
            break;
 
550
        }
 
551
    }
 
552
}
 
553
 
 
554
// parse an expression like " 25 1 ltcorner)"
 
555
void PAGE_LAYOUT_READER_PARSER::parseCoordinate( POINT_COORD& aCoord)
 
556
    throw( IO_ERROR, PARSE_ERROR )
 
557
{
 
558
    T token;
 
559
 
 
560
    aCoord.m_Pos.x = parseDouble();
 
561
    aCoord.m_Pos.y = parseDouble();
 
562
 
 
563
    while( ( token = NextTok() ) != T_RIGHT )
 
564
    {
 
565
        switch( token )
 
566
        {
 
567
            case T_ltcorner:
 
568
                aCoord.m_Anchor = LT_CORNER;   // left top corner
 
569
                break;
 
570
 
 
571
            case T_lbcorner:
 
572
                aCoord.m_Anchor = LB_CORNER;      // left bottom corner
 
573
                break;
 
574
 
 
575
            case T_rbcorner:
 
576
                aCoord.m_Anchor = RB_CORNER;      // right bottom corner
 
577
                break;
 
578
 
 
579
            case T_rtcorner:
 
580
                aCoord.m_Anchor = RT_CORNER;      // right top corner
 
581
                break;
 
582
 
 
583
            default:
 
584
                Unexpected( CurText() );
 
585
                break;
 
586
        }
 
587
    }
 
588
}
 
589
 
 
590
int PAGE_LAYOUT_READER_PARSER::parseInt( int aMin, int aMax )
 
591
{
 
592
    T token = NextTok();
 
593
 
 
594
    if( token != T_NUMBER )
 
595
        Expecting( T_NUMBER );
 
596
 
 
597
    int val = atoi( CurText() );
 
598
 
 
599
    if( val < aMin )
 
600
        val = aMin;
 
601
    else if( val > aMax )
 
602
        val = aMax;
 
603
 
 
604
    return val;
 
605
}
 
606
 
 
607
 
 
608
double PAGE_LAYOUT_READER_PARSER::parseDouble()
 
609
{
 
610
    T token = NextTok();
 
611
 
 
612
    if( token != T_NUMBER )
 
613
        Expecting( T_NUMBER );
 
614
 
 
615
    double val = strtod( CurText(), NULL );
 
616
 
 
617
    return val;
 
618
}
 
619
 
 
620
// defaultPageLayout is the default page layout description
 
621
// using the S expr.
 
622
// see page_layout_default_shape.cpp
 
623
extern const char defaultPageLayout[];
 
624
 
 
625
void WORKSHEET_LAYOUT::SetDefaultLayout()
 
626
{
 
627
    ClearList();
 
628
    PAGE_LAYOUT_READER_PARSER lp_parser( defaultPageLayout, wxT( "default page" ) );
 
629
 
 
630
    try
 
631
    {
 
632
        lp_parser.Parse( this );
 
633
        SetDefaultDescrFlag( true );
 
634
    }
 
635
    catch( IO_ERROR ioe )
 
636
    {
 
637
        wxLogMessage( ioe.errorText );
 
638
    }
 
639
}
 
640
 
 
641
/**
 
642
 * Populates the list from a S expr description stored in a string
 
643
 * @param aPageLayout = the S expr string
 
644
 */
 
645
void WORKSHEET_LAYOUT::SetPageLayout( const char* aPageLayout, bool Append )
 
646
{
 
647
    if( ! Append )
 
648
        ClearList();
 
649
 
 
650
    PAGE_LAYOUT_READER_PARSER lp_parser( aPageLayout, wxT( "Sexpr_string" ) );
 
651
 
 
652
    try
 
653
    {
 
654
        lp_parser.Parse( this );
 
655
        SetDefaultDescrFlag( true );
 
656
    }
 
657
    catch( IO_ERROR ioe )
 
658
    {
 
659
        wxLogMessage( ioe.errorText );
 
660
    }
 
661
}
 
662
 
 
663
#include <wx/file.h>
 
664
 
 
665
// SetLayout() try to load a custom layout file,
 
666
// currently defined by the environment variable KICAD_WKSFILE
 
667
// (a *.kicad_wks file).
 
668
// if does not exists, loads the default page layout.
 
669
void WORKSHEET_LAYOUT::SetPageLayout( const wxString& aFullFileName, bool Append )
 
670
{
 
671
    wxString fullFileName = aFullFileName;
 
672
 
 
673
    if( !Append )
 
674
    {
 
675
        fullFileName = MakeFullFileName( aFullFileName );
 
676
 
 
677
        if( fullFileName.IsEmpty() )
 
678
            wxGetEnv( wxT( "KICAD_WKSFILE" ), &fullFileName );
 
679
 
 
680
        if( fullFileName.IsEmpty() || !wxFileExists( fullFileName ) )
 
681
        {
 
682
            #if 0
 
683
            if( !fullFileName.IsEmpty() )
 
684
            {
 
685
                wxLogMessage( wxT("Page layout file <%s> not found"),
 
686
                              fullFileName.GetData() );
 
687
            }
 
688
            #endif
 
689
            SetDefaultLayout();
 
690
            return;
 
691
        }
 
692
    }
 
693
 
 
694
    wxFile wksFile( fullFileName );
 
695
 
 
696
    if( ! wksFile.IsOpened() )
 
697
    {
 
698
        if( !Append )
 
699
            SetDefaultLayout();
 
700
        return;
 
701
    }
 
702
 
 
703
    int filelen = wksFile.Length();
 
704
    char * buffer = new char[filelen+10];
 
705
 
 
706
    if( wksFile.Read( buffer, filelen ) != filelen )
 
707
        wxLogMessage( _("The file <%s> was not fully read"),
 
708
            fullFileName.GetData() );
 
709
    else
 
710
    {
 
711
        buffer[filelen]=0;
 
712
        if( ! Append )
 
713
            ClearList();
 
714
        PAGE_LAYOUT_READER_PARSER lp_parser( buffer, fullFileName );
 
715
 
 
716
        try
 
717
        {
 
718
            lp_parser.Parse( this );
 
719
            SetDefaultDescrFlag( false );
 
720
        }
 
721
        catch( IO_ERROR ioe )
 
722
        {
 
723
            wxLogMessage( ioe.errorText );
 
724
        }
 
725
    }
 
726
 
 
727
    delete[] buffer;
 
728
}
 
729