root/OpenSceneGraph/trunk/src/osgPlugins/txp/trpage_label.cpp @ 13041

Revision 13041, 19.0 kB (checked in by robert, 3 years ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* ************************
2   Copyright Terrain Experts Inc.
3   Terrain Experts Inc (TERREX) reserves all rights to this source code
4   unless otherwise specified in writing by the President of TERREX.
5   This copyright may be updated in the future, in which case that version
6   supercedes this one.
7   -------------------
8   Terrex Experts Inc.
9   4400 East Broadway #314
10   Tucson, AZ  85711
11   info@terrex.com
12   Tel: (520) 323-7990
13   ************************
14   */
15
16/* trpage_label.cpp
17   Methods for the trpgLable object and its associated support structure
18   including trpgTextStyle and trpgTextStyleTable.
19*/
20
21#include <stdlib.h>
22#include <stdio.h>
23#include <string>
24#include <math.h>
25
26#include <trpage_geom.h>
27#include <trpage_read.h>
28
29// *************** Text Style implementation
30
31trpgTextStyle::trpgTextStyle(void)
32{
33    Reset();
34}
35
36trpgTextStyle::~trpgTextStyle(void)
37{
38}
39
40void trpgTextStyle::Reset(void)
41{
42    font = "";
43    bold = italic = underline = false;
44    characterSize = float32(0.0042333333333); // 12 point in meter
45    matId = -1;
46}
47
48void trpgTextStyle::SetMaterial(int inMatId)
49{
50    matId = inMatId;
51}
52
53int trpgTextStyle::GetMaterial(void) const
54{
55    return matId;
56}
57
58void trpgTextStyle::SetFont(std::string &inFont)
59{
60    font = inFont;
61}
62
63const std::string *trpgTextStyle::GetFont(void) const
64{
65    return &font;
66}
67
68void trpgTextStyle::SetBold(bool inBold)
69{
70    bold = inBold;
71}
72
73bool trpgTextStyle::GetBold(void) const
74{
75    return bold;
76}
77
78void trpgTextStyle::SetItalic(bool inItalic)
79{
80    italic = inItalic;
81}
82
83bool trpgTextStyle::GetItalic(void) const
84{
85    return italic;
86}
87
88void trpgTextStyle::SetUnderline(bool inUnder)
89{
90    underline = inUnder;
91}
92
93bool trpgTextStyle::GetUnderline(void) const
94{
95    return underline;
96}
97
98void trpgTextStyle::SetCharacterSize(float32 inSize)
99{
100    characterSize = inSize;
101}
102
103float32 trpgTextStyle::GetCharacterSize(void) const
104{
105    return characterSize;
106}
107
108
109// Write method
110
111bool trpgTextStyle::Write(trpgWriteBuffer &buf)
112{
113    buf.Begin(TRPG_TEXT_STYLE);
114
115    buf.Begin(TRPG_TEXT_STYLE_BASIC);
116    buf.Add(font);
117    buf.Add((int32)bold);
118    buf.Add((int32)italic);
119    buf.Add((int32)underline);
120    buf.Add(characterSize);
121    buf.Add(matId);
122    buf.End();
123
124    buf.End();
125
126    return true;
127}
128
129// TextStyle CB
130// Used to parse tokens from the text style structure.
131// If we do it this way it's easier to expand later.
132class textStyleCB : public trpgr_Callback
133{
134public:
135    void * Parse(trpgToken,trpgReadBuffer &);
136    trpgTextStyle *style;
137};
138
139void * textStyleCB::Parse(trpgToken tok,trpgReadBuffer &buf)
140{
141    std::string sVal;
142    int iVal;
143    float32 fVal;
144
145    try
146    {
147        switch (tok)
148        {
149        case TRPG_TEXT_STYLE_BASIC:
150            buf.Get(sVal);
151            style->SetFont(sVal);
152            buf.Get(iVal);
153            style->SetBold((iVal ? true : false));
154            buf.Get(iVal);
155            style->SetItalic((iVal ? true : false));
156            buf.Get(iVal);
157            style->SetUnderline((iVal ? true : false));
158            buf.Get(fVal);
159            style->SetCharacterSize(fVal);
160            buf.Get(iVal);
161            style->SetMaterial(iVal);
162            break;
163        default:
164            break;
165        }
166    }
167    catch (...)
168    {
169        return NULL;
170    }
171
172    return style;
173}
174
175// Read from a buffer
176
177bool trpgTextStyle::Read(trpgReadBuffer &buf)
178{
179    Reset();
180
181    trpgr_Parser parse;
182    textStyleCB textStyleCb;
183
184    textStyleCb.style = this;
185    parse.AddCallback(TRPG_TEXT_STYLE_BASIC,&textStyleCb,false);
186    parse.Parse(buf);
187
188    return isValid();
189}
190
191bool trpgTextStyle::isValid(void) const
192{
193    // Need to have a font designation at least
194    if (font.size() > 0)
195        return true;
196
197    return false;
198}
199
200
201bool trpgTextStyle::operator == (const trpgTextStyle& in) const
202{
203    if (font != in.font)
204        return false;
205
206    if (bold      != in.bold ||
207        italic    != in.italic ||
208        underline != in.underline)
209        return false;
210
211    if(fabs(double(characterSize - in.characterSize)) > 0.0001)
212        return false;
213
214
215    if (matId != in.matId)
216        return false;
217
218    return true;
219}
220
221// ******************* Text Style Table implementation
222
223trpgTextStyleTable::trpgTextStyleTable()
224{
225    Reset();
226}
227
228trpgTextStyleTable::~trpgTextStyleTable()
229{
230}
231
232void trpgTextStyleTable::Reset()
233{
234    styleMap.clear();
235}
236
237bool trpgTextStyleTable::isValid() const
238{
239    //for (int i=0;i<styles.size();i++)
240    StyleMapType::const_iterator itr = styleMap.begin();
241    for (  ; itr != styleMap.end( ); itr++)
242        if (!itr->second.isValid())
243            return false;
244
245    return true;
246}
247
248int trpgTextStyleTable::AddStyle(const trpgTextStyle &style)
249{
250    int handle = style.GetHandle();
251    if(handle==-1) {
252        handle = styleMap.size();
253    }
254    styleMap[handle] = style;
255    return handle;
256}
257
258int trpgTextStyleTable::FindAddStyle(const trpgTextStyle &style)
259{
260    StyleMapType::const_iterator itr = styleMap.begin();
261    for (  ; itr != styleMap.end( ); itr++)
262        if (itr->second == style)
263            return itr->first;
264
265    return AddStyle(style);
266}
267
268int trpgTextStyleTable::GetNumStyle() const
269{
270    return styleMap.size();
271}
272
273const trpgTextStyle *trpgTextStyleTable::GetStyleRef(int id) const
274{
275    if (id < 0)
276        return NULL;
277
278    StyleMapType::const_iterator itr = styleMap.find(id);
279    if(itr == styleMap.end())
280        return NULL;
281    return &itr->second;
282}
283
284bool trpgTextStyleTable::Write(trpgWriteBuffer &buf)
285{
286    if (!isValid())
287        return false;
288
289    buf.Begin(TRPG_TEXT_STYLE_TABLE);
290
291    // Number of styles
292    int numStyle = styleMap.size();
293    buf.Add((int32)numStyle);
294
295    // Write the styles
296    StyleMapType::iterator itr = styleMap.begin();
297    for (  ; itr != styleMap.end( ); itr++)
298        itr->second.Write(buf);
299
300    buf.End();
301
302    return true;
303}
304
305bool trpgTextStyleTable::Read(trpgReadBuffer &buf)
306{
307    trpgTextStyle style;
308    trpgToken styleTok;
309    int32 len;
310    bool status;
311    int numStyle;
312    int i;
313
314    Reset();
315
316    try
317    {
318        buf.Get(numStyle);
319        if (numStyle < 0)
320            throw 1;
321
322        for (i=0;i<numStyle;i++) {
323            buf.GetToken(styleTok,len);
324            if (styleTok != TRPG_TEXT_STYLE) throw 1;
325            buf.PushLimit(len);
326            style.Reset();
327            status = style.Read(buf);
328            buf.PopLimit();
329            if (!status) throw 1;
330            AddStyle(style);
331        }
332    }
333    catch (...)
334    {
335        return false;
336    }
337
338    return isValid();
339}
340
341
342
343
344// *************** Support Style implementation
345
346trpgSupportStyle::trpgSupportStyle(void)
347{
348    Reset();
349}
350
351trpgSupportStyle::~trpgSupportStyle(void)
352{
353}
354
355void trpgSupportStyle::Reset(void)
356{
357    type = Line;
358    matId = -1;
359    handle = -1;
360    writeHandle = false;
361}
362
363void trpgSupportStyle::SetType(SupportType s)
364{
365    type = s;
366}
367
368trpgSupportStyle::SupportType trpgSupportStyle::GetType() const
369{
370    return type;
371}
372
373void trpgSupportStyle::SetMaterial(int inMatId)
374{
375    matId = inMatId;
376}
377
378int trpgSupportStyle::GetMaterial(void) const
379{
380    return matId;
381}
382
383// Write method
384bool trpgSupportStyle::Write(trpgWriteBuffer &buf)
385{
386    buf.Begin(TRPG_SUPPORT_STYLE);
387
388    buf.Begin(TRPG_SUPPORT_STYLE_BASIC);
389    buf.Add(type);
390    buf.Add(matId);
391    buf.End();
392
393    buf.End();
394
395    return true;
396}
397
398// SupportStyle CB
399// Used to parse tokens from the support style structure.
400// If we do it this way it's easier to expand later.
401class supportStyleCB : public trpgr_Callback
402{
403public:
404    void * Parse(trpgToken,trpgReadBuffer &);
405    trpgSupportStyle *style;
406};
407
408void * supportStyleCB::Parse(trpgToken tok,trpgReadBuffer &buf)
409{
410    int iVal;
411
412    try
413    {
414        switch (tok)
415        {
416        case TRPG_SUPPORT_STYLE_BASIC:
417            buf.Get(iVal);
418            style->SetType(trpgSupportStyle::SupportType(iVal));
419            buf.Get(iVal);
420            style->SetMaterial(iVal);
421            break;
422        default:
423            break;
424        }
425    }
426    catch (...)
427    {
428        return NULL;
429    }
430
431    return style;
432}
433
434// Read from a buffer
435
436bool trpgSupportStyle::Read(trpgReadBuffer &buf)
437{
438    Reset();
439
440    trpgr_Parser parse;
441    supportStyleCB supportStyleCb;
442
443    supportStyleCb.style = this;
444    parse.AddCallback(TRPG_SUPPORT_STYLE_BASIC,&supportStyleCb,false);
445    parse.Parse(buf);
446
447    return isValid();
448}
449
450bool trpgSupportStyle::isValid(void) const
451{
452    return true;
453}
454
455
456bool trpgSupportStyle::operator == (const trpgSupportStyle& in) const
457{
458    if (type != in.type || matId != in.matId)
459        return false;
460
461    return true;
462}
463
464
465// ******************* Support Style Table implementation
466
467trpgSupportStyleTable::trpgSupportStyleTable()
468{
469    Reset();
470}
471trpgSupportStyleTable::~trpgSupportStyleTable()
472{
473}
474
475void trpgSupportStyleTable::Reset()
476{
477    //styles.resize(0);
478    supportStyleMap.clear();
479}
480
481bool trpgSupportStyleTable::isValid() const
482{
483    //for (int i=0;i<styles.size();i++)
484    SupportStyleMapType::const_iterator itr = supportStyleMap.begin();
485    for (  ; itr != supportStyleMap.end( ); itr++)
486    {
487        if (!itr->second.isValid())
488            return false;
489    }
490    return true;
491}
492
493int trpgSupportStyleTable::AddStyle(const trpgSupportStyle &style)
494{
495    int handle = style.GetHandle();
496    if(handle==-1)
497    {
498        handle = supportStyleMap.size();
499    }
500    supportStyleMap[handle] = style;
501    return handle;
502}
503
504int trpgSupportStyleTable::FindAddStyle(const trpgSupportStyle &style)
505{
506    SupportStyleMapType::const_iterator itr = supportStyleMap.begin();
507    for (  ; itr != supportStyleMap.end( ); itr++)
508        if (itr->second == style)
509            return itr->first;
510
511    return AddStyle(style);
512}
513
514int trpgSupportStyleTable::GetNumStyle() const
515{
516    return supportStyleMap.size();
517}
518
519const trpgSupportStyle *trpgSupportStyleTable::GetStyleRef(int id) const
520{
521    if (id < 0)
522        return NULL;
523    SupportStyleMapType::const_iterator itr = supportStyleMap.find(id);
524    if(itr == supportStyleMap.end())
525        return NULL;
526    return &itr->second;
527}
528
529bool trpgSupportStyleTable::Write(trpgWriteBuffer &buf)
530{
531    if (!isValid())
532        return false;
533
534    buf.Begin(TRPG_SUPPORT_STYLE_TABLE);
535
536    // Number of styles
537    int numStyle = supportStyleMap.size();
538    buf.Add((int32)numStyle);
539
540    // Write the styles
541    SupportStyleMapType::iterator itr = supportStyleMap.begin();
542    for (  ; itr != supportStyleMap.end( ); itr++)
543        itr->second.Write(buf);
544
545    buf.End();
546
547    return true;
548}
549
550bool trpgSupportStyleTable::Read(trpgReadBuffer &buf)
551{
552    trpgSupportStyle style;
553    trpgToken styleTok;
554    int32 len;
555    bool status;
556    int numStyle;
557    int i;
558
559    Reset();
560
561    try
562    {
563        buf.Get(numStyle);
564        if (numStyle < 0)
565            throw 1;
566        //styles.resize(numStyle);
567        for (i=0;i<numStyle;i++) {
568            buf.GetToken(styleTok,len);
569            if (styleTok != TRPG_SUPPORT_STYLE) throw 1;
570            buf.PushLimit(len);
571            style.Reset();
572            status = style.Read(buf);
573            buf.PopLimit();
574            if (!status) throw 1;
575            AddStyle(style);
576        }
577    }
578    catch (...)
579    {
580        return false;
581    }
582
583    return isValid();
584}
585
586
587
588// *************** Label ppoperty implementation
589
590trpgLabelProperty::trpgLabelProperty(void)
591{
592    Reset();
593}
594
595trpgLabelProperty::~trpgLabelProperty(void)
596{
597}
598
599void trpgLabelProperty::Reset(void)
600{
601    fontId = -1;
602    supportId = -1;
603    type = VertBillboard;
604    handle = -1;
605    writeHandle = false;
606}
607
608void trpgLabelProperty::SetType(LabelType inType)
609{
610    type = inType;
611}
612
613trpgLabelProperty::LabelType trpgLabelProperty::GetType() const
614{
615    return type;
616}
617
618void trpgLabelProperty::SetFontStyle(int id)
619{
620    fontId = id;
621}
622
623int trpgLabelProperty::GetFontStyle() const
624{
625    return fontId;
626}
627
628void trpgLabelProperty::SetSupport(int id)
629{
630    supportId = id;
631}
632
633int trpgLabelProperty::GetSupport(void) const
634{
635    return supportId;
636}
637
638// Write method
639bool trpgLabelProperty::Write(trpgWriteBuffer &buf)
640{
641    buf.Begin(TRPG_LABEL_PROPERTY);
642
643    buf.Begin(TRPG_LABEL_PROPERTY_BASIC);
644    buf.Add(fontId);
645    buf.Add(supportId);
646    buf.Add(type);
647    buf.End();
648
649    buf.End();
650
651    return true;
652}
653
654// LabelProperty CB
655// Used to parse tokens from the label property structure.
656// If we do it this way it's easier to expand later.
657class labelPropertyCB : public trpgr_Callback
658{
659public:
660    void * Parse(trpgToken,trpgReadBuffer &);
661    trpgLabelProperty *property;
662};
663
664void * labelPropertyCB::Parse(trpgToken tok,trpgReadBuffer &buf)
665{
666    int iVal;
667
668    try
669    {
670        int ival;
671        switch (tok)
672        {
673        case TRPG_LABEL_PROPERTY_BASIC:
674            buf.Get(iVal);
675            property->SetFontStyle(iVal);
676            buf.Get(iVal);
677            property->SetSupport(iVal);
678            buf.Get(ival);
679            property->SetType(trpgLabelProperty::LabelType(ival));
680            break;
681        default:
682            break;
683        }
684    }
685    catch (...)
686    {
687        return NULL;
688    }
689
690    return property;
691}
692
693// Read from a buffer
694
695bool trpgLabelProperty::Read(trpgReadBuffer &buf)
696{
697    Reset();
698
699    trpgr_Parser parse;
700    labelPropertyCB labelPropertyCb;
701
702    labelPropertyCb.property = this;
703    parse.AddCallback(TRPG_LABEL_PROPERTY_BASIC,&labelPropertyCb,false);
704    parse.Parse(buf);
705
706    return isValid();
707}
708
709bool trpgLabelProperty::isValid(void) const
710{
711    return supportId != -1 && fontId != -1 && type >=0  && type < MaxLabelType;
712}
713
714
715bool trpgLabelProperty::operator == (const trpgLabelProperty& in)const
716{
717    if (fontId != in.fontId || supportId != in.supportId || type != in.type)
718        return false;
719
720    return true;
721}
722
723// ******************* Label Property Table implementation
724
725trpgLabelPropertyTable::trpgLabelPropertyTable()
726{
727    Reset();
728}
729trpgLabelPropertyTable::~trpgLabelPropertyTable()
730{
731}
732
733void trpgLabelPropertyTable::Reset()
734{
735    labelPropertyMap.clear();
736}
737
738bool trpgLabelPropertyTable::isValid() const
739{
740    LabelPropertyMapType::const_iterator itr = labelPropertyMap.begin();
741    for (  ; itr != labelPropertyMap.end( ); itr++)
742    {
743        if (!itr->second.isValid())
744            return false;
745    }
746    return true;
747}
748
749int trpgLabelPropertyTable::AddProperty(const trpgLabelProperty &property)
750{
751    int handle = property.GetHandle();
752    if(handle==-1)
753    {
754        handle = labelPropertyMap.size();
755    }
756    labelPropertyMap[handle] = property;
757    return handle;
758}
759
760int trpgLabelPropertyTable::FindAddProperty(const trpgLabelProperty& property)
761{
762    LabelPropertyMapType::const_iterator itr = labelPropertyMap.begin();
763    for (  ; itr != labelPropertyMap.end( ); itr++)
764    {
765        if (itr->second == property)
766            return itr->first;
767    }
768    return AddProperty(property);
769}
770
771int trpgLabelPropertyTable::GetNumProperty() const
772{
773    return labelPropertyMap.size();
774}
775
776const trpgLabelProperty *trpgLabelPropertyTable::GetPropertyRef(int id) const
777{
778    if (id < 0)
779        return NULL;
780
781    LabelPropertyMapType::const_iterator itr = labelPropertyMap.find(id);
782    if(itr == labelPropertyMap.end())
783        return NULL;
784    return &itr->second;
785}
786
787bool trpgLabelPropertyTable::Write(trpgWriteBuffer &buf)
788{
789    if (!isValid())
790        return false;
791
792    buf.Begin(TRPG_LABEL_PROPERTY_TABLE);
793
794    // Number of styles
795    int numProperty = labelPropertyMap.size();
796    buf.Add((int32)numProperty);
797
798    // Write the properties
799    LabelPropertyMapType::iterator itr = labelPropertyMap.begin();
800    for (  ; itr != labelPropertyMap.end( ); itr++)
801    {
802        itr->second.Write(buf);
803    }
804
805    buf.End();
806
807    return true;
808}
809
810bool trpgLabelPropertyTable::Read(trpgReadBuffer &buf)
811{
812    trpgLabelProperty property;
813    trpgToken propertyTok;
814    int32 len;
815    bool status;
816    int numProperty;
817    int i;
818
819    Reset();
820
821    try
822    {
823        buf.Get(numProperty);
824        if (numProperty < 0)
825            throw 1;
826        //properties.resize(numProperty);
827        for (i=0;i<numProperty;i++) {
828            buf.GetToken(propertyTok,len);
829            if (propertyTok != TRPG_LABEL_PROPERTY) throw 1;
830            buf.PushLimit(len);
831            property.Reset();
832            status = property.Read(buf);
833            buf.PopLimit();
834            if (!status) throw 1;
835            //properties[i] = property;
836            AddProperty(property);
837        }
838    }
839    catch (...)
840    {
841        return false;
842    }
843
844    return isValid();
845}
846
847
848
849// ****************** Label implementation
850
851trpgLabel::trpgLabel()
852{
853    Reset();
854}
855trpgLabel::~trpgLabel()
856{
857}
858
859void trpgLabel::Reset()
860{
861    propertyId = -1;
862    text = "";
863    alignment = Left;
864    tabSize = 8;
865    scale = 1.0;
866    thickness = 0.0;
867    desc = "";
868    url = "";
869    location.x = 0;
870    location.y = 0;
871    location.z = 0;
872    supports.resize(0);
873}
874
875bool trpgLabel::isValid() const
876{
877    if (text.empty() || propertyId == -1)
878        return false;
879
880    return true;
881}
882
883void trpgLabel::SetProperty(int id)
884{
885    propertyId = id;
886}
887
888int trpgLabel::GetProperty() const
889{
890    return propertyId;
891}
892
893
894
895void trpgLabel::SetText(const std::string &inText)
896{
897    text = inText;
898}
899
900const std::string *trpgLabel::GetText() const
901{
902    return &text;
903}
904
905void trpgLabel::SetAlignment(AlignmentType inType)
906{
907    alignment = inType;
908}
909
910trpgLabel::AlignmentType trpgLabel::GetAlignment() const
911{
912    return alignment;
913}
914
915void trpgLabel::SetTab(int size)
916{
917    tabSize = size;
918}
919
920int trpgLabel::GetTab(void) const
921{
922    return tabSize;
923}
924
925void trpgLabel::SetScale(float32 inScale)
926{
927    scale = inScale;
928}
929
930float32 trpgLabel::GetScale(void) const
931{
932    return scale;
933}
934
935void trpgLabel::SetThickness(float32 inThickness)
936{
937    thickness = inThickness;
938}
939
940float32 trpgLabel::GetThickness(void) const
941{
942    return thickness;
943}
944
945void trpgLabel::SetDesc(const std::string &inText)
946{
947    desc = inText;
948}
949
950const std::string *trpgLabel::GetDesc() const
951{
952    return &desc;
953}
954
955
956void trpgLabel::SetURL(const std::string &inText)
957{
958    url = inText;
959}
960
961const std::string *trpgLabel::GetURL() const
962{
963    return &url;
964}
965
966void trpgLabel::SetLocation(const trpg3dPoint &pt)
967{
968    location = pt;
969}
970
971const trpg3dPoint& trpgLabel::GetLocation() const
972{
973    return location;
974}
975
976void trpgLabel::AddSupport(const trpg3dPoint &pt)
977{
978    supports.push_back(pt);
979}
980
981const std::vector<trpg3dPoint> *trpgLabel::GetSupports() const
982{
983    return &supports;
984}
985
986bool trpgLabel::Write(trpgWriteBuffer &buf)
987{
988    unsigned int i;
989
990    buf.Begin(TRPG_LABEL);
991    buf.Add(propertyId);
992    buf.Add(text);
993    buf.Add(alignment);
994    buf.Add(tabSize);
995    buf.Add(scale);
996    buf.Add(thickness);
997    buf.Add(desc);
998    buf.Add(url);
999    buf.Add(location);
1000    buf.Add((int)supports.size());
1001    for (i=0;i<supports.size();i++)
1002        buf.Add(supports[i]);
1003    buf.End();
1004
1005    return true;
1006}
1007
1008bool trpgLabel::Read(trpgReadBuffer &buf)
1009{
1010    int numSupport,i;
1011    trpg3dPoint support;
1012    int iVal;
1013
1014    try
1015    {
1016        buf.Get(iVal);
1017        propertyId = iVal;
1018        buf.Get(text);
1019        buf.Get(iVal);
1020        alignment = (AlignmentType)iVal;
1021        buf.Get(tabSize);
1022        buf.Get(scale);
1023        buf.Get(thickness);
1024        buf.Get(desc);
1025        buf.Get(url);
1026        buf.Get(location);
1027        buf.Get(numSupport);
1028        if (numSupport < 0) throw 1;
1029        for (i=0;i<numSupport;i++) {
1030            buf.Get(support);
1031            supports.push_back(support);
1032        }
1033    }
1034    catch (...)
1035    {
1036        return false;
1037    }
1038
1039    return isValid();
1040}
Note: See TracBrowser for help on using the browser.