author | Michael Krelin <hacker@klever.net> | 2007-07-04 11:23:42 (UTC) |
---|---|---|
committer | Michael Krelin <hacker@klever.net> | 2007-07-04 11:23:42 (UTC) |
commit | a08aff328d4393031d5ba7d622c2b05705a89d73 (patch) (unidiff) | |
tree | 8ee90d686081c52e7c69b5ce946e9b1a7d690001 /kabc/vcard | |
parent | 11edc920afe4f274c0964436633aa632c8288a40 (diff) | |
download | kdepimpi-p1.zip kdepimpi-p1.tar.gz kdepimpi-p1.tar.bz2 |
initial public commit of qt4 portp1
110 files changed, 617 insertions, 455 deletions
diff --git a/kabc/vcard/AdrParam.cpp b/kabc/vcard/AdrParam.cpp index fa46499..33d358c 100644 --- a/kabc/vcard/AdrParam.cpp +++ b/kabc/vcard/AdrParam.cpp | |||
@@ -1,126 +1,128 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardRToken.h> | 24 | #include <VCardRToken.h> |
25 | #include <VCardAdrParam.h> | 25 | #include <VCardAdrParam.h> |
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | AdrParam::AdrParam() | 32 | AdrParam::AdrParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | AdrParam::AdrParam(const AdrParam & x) | 37 | AdrParam::AdrParam(const AdrParam & x) |
36 | :Param(x), | 38 | :Param(x), |
37 | adrTypeList_(x.adrTypeList_) | 39 | adrTypeList_(x.adrTypeList_) |
38 | { | 40 | { |
39 | } | 41 | } |
40 | 42 | ||
41 | AdrParam::AdrParam(const QCString & s) | 43 | AdrParam::AdrParam(const Q3CString & s) |
42 | :Param(s) | 44 | :Param(s) |
43 | { | 45 | { |
44 | } | 46 | } |
45 | 47 | ||
46 | AdrParam & | 48 | AdrParam & |
47 | AdrParam::operator = (AdrParam & x) | 49 | AdrParam::operator = (AdrParam & x) |
48 | { | 50 | { |
49 | if (*this == x) return *this; | 51 | if (*this == x) return *this; |
50 | 52 | ||
51 | adrTypeList_= x.adrTypeList(); | 53 | adrTypeList_= x.adrTypeList(); |
52 | textParam_ = x.textParam(); | 54 | textParam_ = x.textParam(); |
53 | 55 | ||
54 | Param::operator = (x); | 56 | Param::operator = (x); |
55 | return *this; | 57 | return *this; |
56 | } | 58 | } |
57 | 59 | ||
58 | AdrParam & | 60 | AdrParam & |
59 | AdrParam::operator = (const QCString & s) | 61 | AdrParam::operator = (const Q3CString & s) |
60 | { | 62 | { |
61 | Param::operator = (s); | 63 | Param::operator = (s); |
62 | 64 | ||
63 | adrTypeList_.clear(); | 65 | adrTypeList_.clear(); |
64 | textParam_.truncate(0); | 66 | textParam_.truncate(0); |
65 | 67 | ||
66 | return *this; | 68 | return *this; |
67 | } | 69 | } |
68 | 70 | ||
69 | bool | 71 | bool |
70 | AdrParam::operator == (AdrParam & x) | 72 | AdrParam::operator == (AdrParam & x) |
71 | { | 73 | { |
72 | parse(); | 74 | parse(); |
73 | 75 | ||
74 | if (!x.textParam().isEmpty()) | 76 | if (!x.textParam().isEmpty()) |
75 | return (x.textParam_ == textParam_); | 77 | return (x.textParam_ == textParam_); |
76 | 78 | ||
77 | if (x.adrTypeList().count() != adrTypeList_.count()) | 79 | if (x.adrTypeList().count() != adrTypeList_.count()) |
78 | return false; | 80 | return false; |
79 | 81 | ||
80 | QStrListIterator it(x.adrTypeList_); | 82 | Q3StrListIterator it(x.adrTypeList_); |
81 | 83 | ||
82 | for (; it.current(); ++it) | 84 | for (; it.current(); ++it) |
83 | if (!adrTypeList_.find(it.current())) | 85 | if (!adrTypeList_.find(it.current())) |
84 | return false; | 86 | return false; |
85 | 87 | ||
86 | return true; | 88 | return true; |
87 | } | 89 | } |
88 | 90 | ||
89 | AdrParam::~AdrParam() | 91 | AdrParam::~AdrParam() |
90 | { | 92 | { |
91 | } | 93 | } |
92 | 94 | ||
93 | void | 95 | void |
94 | AdrParam::_parse() | 96 | AdrParam::_parse() |
95 | { | 97 | { |
96 | adrTypeList_.clear(); | 98 | adrTypeList_.clear(); |
97 | 99 | ||
98 | if (strRep_.left(4) != "TYPE") { | 100 | if (strRep_.left(4) != "TYPE") { |
99 | textParam_ = strRep_; | 101 | textParam_ = strRep_; |
100 | return; | 102 | return; |
101 | } | 103 | } |
102 | 104 | ||
103 | if (!strRep_.contains('=')) | 105 | if (!strRep_.contains('=')) |
104 | return; | 106 | return; |
105 | 107 | ||
106 | RTokenise(strRep_, ",", adrTypeList_); | 108 | RTokenise(strRep_, ",", adrTypeList_); |
107 | } | 109 | } |
108 | 110 | ||
109 | void | 111 | void |
110 | AdrParam::_assemble() | 112 | AdrParam::_assemble() |
111 | { | 113 | { |
112 | if (!textParam_.isEmpty()) { | 114 | if (!textParam_.isEmpty()) { |
113 | strRep_ = textParam_; | 115 | strRep_ = textParam_; |
114 | return; | 116 | return; |
115 | } | 117 | } |
116 | 118 | ||
117 | QStrListIterator it(adrTypeList_); | 119 | Q3StrListIterator it(adrTypeList_); |
118 | 120 | ||
119 | for (; it.current(); ++it) { | 121 | for (; it.current(); ++it) { |
120 | 122 | ||
121 | strRep_ += it.current(); | 123 | strRep_ += it.current(); |
122 | 124 | ||
123 | if (it.current() != adrTypeList_.last()) | 125 | if (it.current() != adrTypeList_.last()) |
124 | strRep_ += ','; | 126 | strRep_ += ','; |
125 | } | 127 | } |
126 | } | 128 | } |
diff --git a/kabc/vcard/AdrValue.cpp b/kabc/vcard/AdrValue.cpp index 7ecef33..51ca12a 100644 --- a/kabc/vcard/AdrValue.cpp +++ b/kabc/vcard/AdrValue.cpp | |||
@@ -1,140 +1,143 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardRToken.h> | 24 | #include <VCardRToken.h> |
25 | #include <VCardAdrValue.h> | 25 | #include <VCardAdrValue.h> |
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | #include <VCardDefines.h> | 27 | #include <VCardDefines.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3StrList> | ||
30 | #include <Q3CString> | ||
28 | 31 | ||
29 | using namespace VCARD; | 32 | using namespace VCARD; |
30 | 33 | ||
31 | AdrValue::AdrValue() | 34 | AdrValue::AdrValue() |
32 | :Value() | 35 | :Value() |
33 | { | 36 | { |
34 | } | 37 | } |
35 | 38 | ||
36 | AdrValue::AdrValue(const AdrValue & x) | 39 | AdrValue::AdrValue(const AdrValue & x) |
37 | :Value(x), | 40 | :Value(x), |
38 | poBox_ (x.poBox_), | 41 | poBox_ (x.poBox_), |
39 | extAddress_(x.extAddress_), | 42 | extAddress_(x.extAddress_), |
40 | street_ (x.street_), | 43 | street_ (x.street_), |
41 | locality_(x.locality_), | 44 | locality_(x.locality_), |
42 | region_ (x.region_), | 45 | region_ (x.region_), |
43 | postCode_(x.postCode_), | 46 | postCode_(x.postCode_), |
44 | countryName_(x.countryName_) | 47 | countryName_(x.countryName_) |
45 | { | 48 | { |
46 | } | 49 | } |
47 | 50 | ||
48 | AdrValue::AdrValue(const QCString & s) | 51 | AdrValue::AdrValue(const Q3CString & s) |
49 | :Value(s) | 52 | :Value(s) |
50 | { | 53 | { |
51 | } | 54 | } |
52 | 55 | ||
53 | AdrValue & | 56 | AdrValue & |
54 | AdrValue::operator = (AdrValue & x) | 57 | AdrValue::operator = (AdrValue & x) |
55 | { | 58 | { |
56 | if (*this == x) return *this; | 59 | if (*this == x) return *this; |
57 | 60 | ||
58 | poBox_ = x.poBox_; | 61 | poBox_ = x.poBox_; |
59 | extAddress_= x.extAddress_; | 62 | extAddress_= x.extAddress_; |
60 | street_ = x.street_; | 63 | street_ = x.street_; |
61 | locality_= x.locality_; | 64 | locality_= x.locality_; |
62 | region_ = x.region_; | 65 | region_ = x.region_; |
63 | postCode_= x.postCode_; | 66 | postCode_= x.postCode_; |
64 | countryName_= x.countryName_; | 67 | countryName_= x.countryName_; |
65 | 68 | ||
66 | Value::operator = (x); | 69 | Value::operator = (x); |
67 | return *this; | 70 | return *this; |
68 | } | 71 | } |
69 | 72 | ||
70 | AdrValue & | 73 | AdrValue & |
71 | AdrValue::operator = (const QCString & s) | 74 | AdrValue::operator = (const Q3CString & s) |
72 | { | 75 | { |
73 | Value::operator = (s); | 76 | Value::operator = (s); |
74 | return *this; | 77 | return *this; |
75 | } | 78 | } |
76 | 79 | ||
77 | bool | 80 | bool |
78 | AdrValue::operator == (AdrValue & x) | 81 | AdrValue::operator == (AdrValue & x) |
79 | { | 82 | { |
80 | parse(); | 83 | parse(); |
81 | x.parse(); | 84 | x.parse(); |
82 | 85 | ||
83 | return ( | 86 | return ( |
84 | poBox_ == x.poBox_ && | 87 | poBox_ == x.poBox_ && |
85 | extAddress_ == x.extAddress_&& | 88 | extAddress_ == x.extAddress_&& |
86 | street_ == x.street_ && | 89 | street_ == x.street_ && |
87 | locality_ == x.locality_ && | 90 | locality_ == x.locality_ && |
88 | region_ == x.region_ && | 91 | region_ == x.region_ && |
89 | postCode_ == x.postCode_ && | 92 | postCode_ == x.postCode_ && |
90 | countryName_== x.countryName_); | 93 | countryName_== x.countryName_); |
91 | } | 94 | } |
92 | 95 | ||
93 | AdrValue::~AdrValue() | 96 | AdrValue::~AdrValue() |
94 | { | 97 | { |
95 | } | 98 | } |
96 | 99 | ||
97 | AdrValue * | 100 | AdrValue * |
98 | AdrValue::clone() | 101 | AdrValue::clone() |
99 | { | 102 | { |
100 | return new AdrValue( *this ); | 103 | return new AdrValue( *this ); |
101 | } | 104 | } |
102 | 105 | ||
103 | void | 106 | void |
104 | AdrValue::_parse() | 107 | AdrValue::_parse() |
105 | { | 108 | { |
106 | vDebug("AdrValue::_parse()"); | 109 | vDebug("AdrValue::_parse()"); |
107 | 110 | ||
108 | QStrList l; | 111 | Q3StrList l; |
109 | RTokenise(strRep_, ";", l); | 112 | RTokenise(strRep_, ";", l); |
110 | 113 | ||
111 | for (unsigned int i = 0; i < l.count(); i++) { | 114 | for (unsigned int i = 0; i < l.count(); i++) { |
112 | 115 | ||
113 | switch (i) { | 116 | switch (i) { |
114 | 117 | ||
115 | case 0: poBox_ = l.at(0);break; | 118 | case 0: poBox_ = l.at(0);break; |
116 | case 1: extAddress_ = l.at(1);break; | 119 | case 1: extAddress_ = l.at(1);break; |
117 | case 2: street_ = l.at(2);break; | 120 | case 2: street_ = l.at(2);break; |
118 | case 3: locality_ = l.at(3);break; | 121 | case 3: locality_ = l.at(3);break; |
119 | case 4: region_ = l.at(4);break; | 122 | case 4: region_ = l.at(4);break; |
120 | case 5: postCode_ = l.at(5);break; | 123 | case 5: postCode_ = l.at(5);break; |
121 | case 6: countryName_ = l.at(6);break; | 124 | case 6: countryName_ = l.at(6);break; |
122 | default: break; | 125 | default: break; |
123 | } | 126 | } |
124 | } | 127 | } |
125 | } | 128 | } |
126 | 129 | ||
127 | void | 130 | void |
128 | AdrValue::_assemble() | 131 | AdrValue::_assemble() |
129 | { | 132 | { |
130 | vDebug("AdrValue::_assemble"); | 133 | vDebug("AdrValue::_assemble"); |
131 | 134 | ||
132 | strRep_ = poBox_; | 135 | strRep_ = poBox_; |
133 | strRep_ += ";" +extAddress_; | 136 | strRep_ += ";" +extAddress_; |
134 | strRep_ += ";" +street_; | 137 | strRep_ += ";" +street_; |
135 | strRep_ += ";" +locality_; | 138 | strRep_ += ";" +locality_; |
136 | strRep_ += ";" +region_; | 139 | strRep_ += ";" +region_; |
137 | strRep_ += ";" +postCode_; | 140 | strRep_ += ";" +postCode_; |
138 | strRep_ += ";" +countryName_; | 141 | strRep_ += ";" +countryName_; |
139 | } | 142 | } |
140 | 143 | ||
diff --git a/kabc/vcard/AgentParam.cpp b/kabc/vcard/AgentParam.cpp index 5625e00..aae35ac 100644 --- a/kabc/vcard/AgentParam.cpp +++ b/kabc/vcard/AgentParam.cpp | |||
@@ -1,103 +1,105 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardAgentParam.h> | 24 | #include <VCardAgentParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | AgentParam::AgentParam() | 32 | AgentParam::AgentParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | AgentParam::AgentParam(const AgentParam & x) | 37 | AgentParam::AgentParam(const AgentParam & x) |
36 | :Param(x), | 38 | :Param(x), |
37 | refer_(x.refer_), | 39 | refer_(x.refer_), |
38 | uri_(x.uri_) | 40 | uri_(x.uri_) |
39 | { | 41 | { |
40 | } | 42 | } |
41 | 43 | ||
42 | AgentParam::AgentParam(const QCString & s) | 44 | AgentParam::AgentParam(const Q3CString & s) |
43 | :Param(s) | 45 | :Param(s) |
44 | { | 46 | { |
45 | } | 47 | } |
46 | 48 | ||
47 | AgentParam & | 49 | AgentParam & |
48 | AgentParam::operator = (AgentParam & x) | 50 | AgentParam::operator = (AgentParam & x) |
49 | { | 51 | { |
50 | if (*this == x) return *this; | 52 | if (*this == x) return *this; |
51 | 53 | ||
52 | refer_= x.refer_; | 54 | refer_= x.refer_; |
53 | uri_= x.uri_; | 55 | uri_= x.uri_; |
54 | 56 | ||
55 | Param::operator = (x); | 57 | Param::operator = (x); |
56 | return *this; | 58 | return *this; |
57 | } | 59 | } |
58 | 60 | ||
59 | AgentParam & | 61 | AgentParam & |
60 | AgentParam::operator = (const QCString & s) | 62 | AgentParam::operator = (const Q3CString & s) |
61 | { | 63 | { |
62 | Param::operator = (s); | 64 | Param::operator = (s); |
63 | return *this; | 65 | return *this; |
64 | } | 66 | } |
65 | 67 | ||
66 | bool | 68 | bool |
67 | AgentParam::operator == (AgentParam & x) | 69 | AgentParam::operator == (AgentParam & x) |
68 | { | 70 | { |
69 | parse(); | 71 | parse(); |
70 | 72 | ||
71 | if (refer_) | 73 | if (refer_) |
72 | return (x.refer() && uri_ == x.uri_); | 74 | return (x.refer() && uri_ == x.uri_); |
73 | 75 | ||
74 | return !x.refer(); | 76 | return !x.refer(); |
75 | } | 77 | } |
76 | 78 | ||
77 | AgentParam::~AgentParam() | 79 | AgentParam::~AgentParam() |
78 | { | 80 | { |
79 | } | 81 | } |
80 | 82 | ||
81 | void | 83 | void |
82 | AgentParam::_parse() | 84 | AgentParam::_parse() |
83 | { | 85 | { |
84 | if (strRep_.isEmpty()) { | 86 | if (strRep_.isEmpty()) { |
85 | refer_ = false; | 87 | refer_ = false; |
86 | return; | 88 | return; |
87 | } | 89 | } |
88 | 90 | ||
89 | refer_= true; | 91 | refer_= true; |
90 | uri_= strRep_; | 92 | uri_= strRep_; |
91 | } | 93 | } |
92 | 94 | ||
93 | void | 95 | void |
94 | AgentParam::_assemble() | 96 | AgentParam::_assemble() |
95 | { | 97 | { |
96 | if (!refer_) { | 98 | if (!refer_) { |
97 | strRep_.truncate(0); | 99 | strRep_.truncate(0); |
98 | return; | 100 | return; |
99 | } | 101 | } |
100 | 102 | ||
101 | strRep_ = uri_.asString(); | 103 | strRep_ = uri_.asString(); |
102 | return; | 104 | return; |
103 | } | 105 | } |
diff --git a/kabc/vcard/AgentValue.cpp b/kabc/vcard/AgentValue.cpp index bccde80..14e73b1 100644 --- a/kabc/vcard/AgentValue.cpp +++ b/kabc/vcard/AgentValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardAgentValue.h> | 24 | #include <VCardAgentValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | AgentValue::AgentValue() | 32 | AgentValue::AgentValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | AgentValue::AgentValue(const AgentValue & x) | 37 | AgentValue::AgentValue(const AgentValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | AgentValue::AgentValue(const QCString & s) | 42 | AgentValue::AgentValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | AgentValue & | 47 | AgentValue & |
46 | AgentValue::operator = (AgentValue & x) | 48 | AgentValue::operator = (AgentValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | AgentValue & | 56 | AgentValue & |
55 | AgentValue::operator = (const QCString & s) | 57 | AgentValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | AgentValue::operator == (AgentValue & x) | 64 | AgentValue::operator == (AgentValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | AgentValue::~AgentValue() | 70 | AgentValue::~AgentValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | AgentValue::_parse() | 75 | AgentValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | AgentValue::_assemble() | 80 | AgentValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/ClassValue.cpp b/kabc/vcard/ClassValue.cpp index f01e5a6..c088d7c 100644 --- a/kabc/vcard/ClassValue.cpp +++ b/kabc/vcard/ClassValue.cpp | |||
@@ -1,120 +1,122 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardClassValue.h> | 24 | #include <VCardClassValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | 27 | ||
28 | #include <kdebug.h> | 28 | #include <kdebug.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
29 | 31 | ||
30 | using namespace VCARD; | 32 | using namespace VCARD; |
31 | 33 | ||
32 | ClassValue::ClassValue() | 34 | ClassValue::ClassValue() |
33 | :Value() | 35 | :Value() |
34 | { | 36 | { |
35 | } | 37 | } |
36 | 38 | ||
37 | ClassValue::ClassValue(const ClassValue & x) | 39 | ClassValue::ClassValue(const ClassValue & x) |
38 | :Value(x), | 40 | :Value(x), |
39 | classType_(x.classType_) | 41 | classType_(x.classType_) |
40 | { | 42 | { |
41 | } | 43 | } |
42 | 44 | ||
43 | ClassValue::ClassValue(const QCString & s) | 45 | ClassValue::ClassValue(const Q3CString & s) |
44 | :Value(s) | 46 | :Value(s) |
45 | { | 47 | { |
46 | } | 48 | } |
47 | 49 | ||
48 | ClassValue & | 50 | ClassValue & |
49 | ClassValue::operator = (ClassValue & x) | 51 | ClassValue::operator = (ClassValue & x) |
50 | { | 52 | { |
51 | if (*this == x) return *this; | 53 | if (*this == x) return *this; |
52 | x.parse(); | 54 | x.parse(); |
53 | 55 | ||
54 | classType_ = x.classType_; | 56 | classType_ = x.classType_; |
55 | 57 | ||
56 | Value::operator = (x); | 58 | Value::operator = (x); |
57 | return *this; | 59 | return *this; |
58 | } | 60 | } |
59 | 61 | ||
60 | ClassValue & | 62 | ClassValue & |
61 | ClassValue::operator = (const QCString & s) | 63 | ClassValue::operator = (const Q3CString & s) |
62 | { | 64 | { |
63 | Value::operator = (s); | 65 | Value::operator = (s); |
64 | return *this; | 66 | return *this; |
65 | } | 67 | } |
66 | 68 | ||
67 | bool | 69 | bool |
68 | ClassValue::operator == (ClassValue & x) | 70 | ClassValue::operator == (ClassValue & x) |
69 | { | 71 | { |
70 | x.parse(); | 72 | x.parse(); |
71 | return ( classType_ == x.classType_ ); | 73 | return ( classType_ == x.classType_ ); |
72 | } | 74 | } |
73 | 75 | ||
74 | ClassValue::~ClassValue() | 76 | ClassValue::~ClassValue() |
75 | { | 77 | { |
76 | } | 78 | } |
77 | 79 | ||
78 | ClassValue * | 80 | ClassValue * |
79 | ClassValue::clone() | 81 | ClassValue::clone() |
80 | { | 82 | { |
81 | return new ClassValue( *this ); | 83 | return new ClassValue( *this ); |
82 | } | 84 | } |
83 | 85 | ||
84 | void | 86 | void |
85 | ClassValue::_parse() | 87 | ClassValue::_parse() |
86 | { | 88 | { |
87 | if (qstricmp(strRep_, "PUBLIC") == 0) | 89 | if (qstricmp(strRep_, "PUBLIC") == 0) |
88 | classType_ = Public; | 90 | classType_ = Public; |
89 | 91 | ||
90 | else if (qstricmp(strRep_, "PRIVATE") == 0) | 92 | else if (qstricmp(strRep_, "PRIVATE") == 0) |
91 | classType_ = Private; | 93 | classType_ = Private; |
92 | 94 | ||
93 | else if (qstricmp(strRep_, "CONFIDENTIAL") == 0) | 95 | else if (qstricmp(strRep_, "CONFIDENTIAL") == 0) |
94 | classType_ = Confidential; | 96 | classType_ = Confidential; |
95 | 97 | ||
96 | else classType_ = Other; | 98 | else classType_ = Other; |
97 | } | 99 | } |
98 | 100 | ||
99 | void | 101 | void |
100 | ClassValue::_assemble() | 102 | ClassValue::_assemble() |
101 | { | 103 | { |
102 | switch (classType_) { | 104 | switch (classType_) { |
103 | 105 | ||
104 | case Public: | 106 | case Public: |
105 | strRep_ = "PUBLIC"; | 107 | strRep_ = "PUBLIC"; |
106 | break; | 108 | break; |
107 | 109 | ||
108 | case Private: | 110 | case Private: |
109 | strRep_ = "PRIVATE"; | 111 | strRep_ = "PRIVATE"; |
110 | break; | 112 | break; |
111 | 113 | ||
112 | case Confidential: | 114 | case Confidential: |
113 | strRep_ = "CONFIDENTIAL"; | 115 | strRep_ = "CONFIDENTIAL"; |
114 | break; | 116 | break; |
115 | 117 | ||
116 | default: | 118 | default: |
117 | break; | 119 | break; |
118 | } | 120 | } |
119 | } | 121 | } |
120 | 122 | ||
diff --git a/kabc/vcard/ContentLine.cpp b/kabc/vcard/ContentLine.cpp index 0a2f97d..1d4886c 100644 --- a/kabc/vcard/ContentLine.cpp +++ b/kabc/vcard/ContentLine.cpp | |||
@@ -1,355 +1,355 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qcstring.h> | 24 | #include <q3cstring.h> |
25 | #include <qstrlist.h> | 25 | #include <q3strlist.h> |
26 | #include <qregexp.h> | 26 | #include <qregexp.h> |
27 | 27 | ||
28 | #include <kdebug.h> | 28 | #include <kdebug.h> |
29 | 29 | ||
30 | #include <VCardAdrParam.h> | 30 | #include <VCardAdrParam.h> |
31 | #include <VCardAgentParam.h> | 31 | #include <VCardAgentParam.h> |
32 | #include <VCardDateParam.h> | 32 | #include <VCardDateParam.h> |
33 | #include <VCardEmailParam.h> | 33 | #include <VCardEmailParam.h> |
34 | #include <VCardImageParam.h> | 34 | #include <VCardImageParam.h> |
35 | #include <VCardSourceParam.h> | 35 | #include <VCardSourceParam.h> |
36 | #include <VCardTelParam.h> | 36 | #include <VCardTelParam.h> |
37 | #include <VCardTextBinParam.h> | 37 | #include <VCardTextBinParam.h> |
38 | #include <VCardTextParam.h> | 38 | #include <VCardTextParam.h> |
39 | 39 | ||
40 | #include <VCardAdrValue.h> | 40 | #include <VCardAdrValue.h> |
41 | #include <VCardAgentValue.h> | 41 | #include <VCardAgentValue.h> |
42 | #include <VCardDateValue.h> | 42 | #include <VCardDateValue.h> |
43 | #include <VCardImageValue.h> | 43 | #include <VCardImageValue.h> |
44 | #include <VCardTextValue.h> | 44 | #include <VCardTextValue.h> |
45 | #include <VCardTextBinValue.h> | 45 | #include <VCardTextBinValue.h> |
46 | #include <VCardLangValue.h> | 46 | #include <VCardLangValue.h> |
47 | #include <VCardNValue.h> | 47 | #include <VCardNValue.h> |
48 | #include <VCardURIValue.h> | 48 | #include <VCardURIValue.h> |
49 | #include <VCardSoundValue.h> | 49 | #include <VCardSoundValue.h> |
50 | #include <VCardClassValue.h> | 50 | #include <VCardClassValue.h> |
51 | #include <VCardFloatValue.h> | 51 | #include <VCardFloatValue.h> |
52 | #include <VCardOrgValue.h> | 52 | #include <VCardOrgValue.h> |
53 | #include <VCardTelValue.h> | 53 | #include <VCardTelValue.h> |
54 | #include <VCardTextListValue.h> | 54 | #include <VCardTextListValue.h> |
55 | #include <VCardUTCValue.h> | 55 | #include <VCardUTCValue.h> |
56 | #include <VCardGeoValue.h> | 56 | #include <VCardGeoValue.h> |
57 | 57 | ||
58 | #include <VCardRToken.h> | 58 | #include <VCardRToken.h> |
59 | #include <VCardContentLine.h> | 59 | #include <VCardContentLine.h> |
60 | 60 | ||
61 | #include <VCardEntity.h> | 61 | #include <VCardEntity.h> |
62 | #include <VCardEnum.h> | 62 | #include <VCardEnum.h> |
63 | #include <VCardDefines.h> | 63 | #include <VCardDefines.h> |
64 | 64 | ||
65 | using namespace VCARD; | 65 | using namespace VCARD; |
66 | 66 | ||
67 | ContentLine::ContentLine() | 67 | ContentLine::ContentLine() |
68 | :Entity(), | 68 | :Entity(), |
69 | value_(0), | 69 | value_(0), |
70 | paramType_( ParamUnknown ), | 70 | paramType_( ParamUnknown ), |
71 | valueType_( ValueUnknown ), | 71 | valueType_( ValueUnknown ), |
72 | entityType_( EntityUnknown ) | 72 | entityType_( EntityUnknown ) |
73 | { | 73 | { |
74 | paramList_.setAutoDelete( TRUE ); | 74 | paramList_.setAutoDelete( TRUE ); |
75 | } | 75 | } |
76 | 76 | ||
77 | ContentLine::ContentLine(const ContentLine & x) | 77 | ContentLine::ContentLine(const ContentLine & x) |
78 | :Entity(x), | 78 | :Entity(x), |
79 | group_ (x.group_), | 79 | group_ (x.group_), |
80 | name_ (x.name_), | 80 | name_ (x.name_), |
81 | /*US paramList_(x.paramList_),*/ | 81 | /*US paramList_(x.paramList_),*/ |
82 | value_(x.value_->clone()), | 82 | value_(x.value_->clone()), |
83 | paramType_(x.paramType_), | 83 | paramType_(x.paramType_), |
84 | valueType_(x.valueType_), | 84 | valueType_(x.valueType_), |
85 | entityType_(x.entityType_) | 85 | entityType_(x.entityType_) |
86 | { | 86 | { |
87 | paramList_.setAutoDelete( TRUE ); | 87 | paramList_.setAutoDelete( TRUE ); |
88 | 88 | ||
89 | 89 | ||
90 | ParamListIterator it(x.paramList_); | 90 | ParamListIterator it(x.paramList_); |
91 | for (; it.current(); ++it) | 91 | for (; it.current(); ++it) |
92 | { | 92 | { |
93 | Param *p = new Param; | 93 | Param *p = new Param; |
94 | p->setName( it.current()->name() ); | 94 | p->setName( it.current()->name() ); |
95 | p->setValue( it.current()->value() ); | 95 | p->setValue( it.current()->value() ); |
96 | paramList_.append(p); | 96 | paramList_.append(p); |
97 | } | 97 | } |
98 | 98 | ||
99 | } | 99 | } |
100 | 100 | ||
101 | ContentLine::ContentLine(const QCString & s) | 101 | ContentLine::ContentLine(const Q3CString & s) |
102 | :Entity(s), | 102 | :Entity(s), |
103 | value_(0), | 103 | value_(0), |
104 | paramType_( ParamUnknown ), | 104 | paramType_( ParamUnknown ), |
105 | valueType_( ValueUnknown ), | 105 | valueType_( ValueUnknown ), |
106 | entityType_( EntityUnknown ) | 106 | entityType_( EntityUnknown ) |
107 | { | 107 | { |
108 | paramList_.setAutoDelete( TRUE ); | 108 | paramList_.setAutoDelete( TRUE ); |
109 | } | 109 | } |
110 | 110 | ||
111 | ContentLine & | 111 | ContentLine & |
112 | ContentLine::operator = (ContentLine & x) | 112 | ContentLine::operator = (ContentLine & x) |
113 | { | 113 | { |
114 | if (*this == x) return *this; | 114 | if (*this == x) return *this; |
115 | 115 | ||
116 | ParamListIterator it(x.paramList_); | 116 | ParamListIterator it(x.paramList_); |
117 | for (; it.current(); ++it) | 117 | for (; it.current(); ++it) |
118 | { | 118 | { |
119 | Param *p = new Param; | 119 | Param *p = new Param; |
120 | p->setName( it.current()->name() ); | 120 | p->setName( it.current()->name() ); |
121 | p->setValue( it.current()->value() ); | 121 | p->setValue( it.current()->value() ); |
122 | paramList_.append(p); | 122 | paramList_.append(p); |
123 | } | 123 | } |
124 | 124 | ||
125 | value_ = x.value_->clone(); | 125 | value_ = x.value_->clone(); |
126 | 126 | ||
127 | Entity::operator = (x); | 127 | Entity::operator = (x); |
128 | return *this; | 128 | return *this; |
129 | } | 129 | } |
130 | 130 | ||
131 | ContentLine & | 131 | ContentLine & |
132 | ContentLine::operator = (const QCString & s) | 132 | ContentLine::operator = (const Q3CString & s) |
133 | { | 133 | { |
134 | Entity::operator = (s); | 134 | Entity::operator = (s); |
135 | delete value_; | 135 | delete value_; |
136 | value_ = 0; | 136 | value_ = 0; |
137 | return *this; | 137 | return *this; |
138 | } | 138 | } |
139 | 139 | ||
140 | bool | 140 | bool |
141 | ContentLine::operator == (ContentLine & x) | 141 | ContentLine::operator == (ContentLine & x) |
142 | { | 142 | { |
143 | x.parse(); | 143 | x.parse(); |
144 | 144 | ||
145 | QPtrListIterator<Param> it(x.paramList()); | 145 | Q3PtrListIterator<Param> it(x.paramList()); |
146 | 146 | ||
147 | if (!paramList_.find(it.current())) | 147 | if (!paramList_.find(it.current())) |
148 | return false; | 148 | return false; |
149 | 149 | ||
150 | return true; | 150 | return true; |
151 | } | 151 | } |
152 | 152 | ||
153 | ContentLine::~ContentLine() | 153 | ContentLine::~ContentLine() |
154 | { | 154 | { |
155 | delete value_; | 155 | delete value_; |
156 | value_ = 0; | 156 | value_ = 0; |
157 | } | 157 | } |
158 | 158 | ||
159 | void | 159 | void |
160 | ContentLine::_parse() | 160 | ContentLine::_parse() |
161 | { | 161 | { |
162 | vDebug("parse"); | 162 | vDebug("parse"); |
163 | 163 | ||
164 | // Unfold folded lines | 164 | // Unfold folded lines |
165 | // NLR | 165 | // NLR |
166 | strRep_ = strRep_.replace( QRegExp( "\\r" ), "" ); | 166 | strRep_ = strRep_.replace( "\\r" , "" ); |
167 | // Unqote newlines | 167 | // Unqote newlines |
168 | strRep_ = strRep_.replace( QRegExp( "\\\\n" ), "\n" ); | 168 | strRep_ = strRep_.replace( "\\\\n", "\n" ); |
169 | //NLR | 169 | //NLR |
170 | strRep_ = strRep_.replace( QRegExp( "\\\\r" ), "\r" ); | 170 | strRep_ = strRep_.replace( "\\\\r" , "\r" ); |
171 | 171 | ||
172 | int split = strRep_.find(':'); | 172 | int split = strRep_.find(':'); |
173 | 173 | ||
174 | if (split == -1) { // invalid content line | 174 | if (split == -1) { // invalid content line |
175 | vDebug("No ':'"); | 175 | vDebug("No ':'"); |
176 | return; | 176 | return; |
177 | } | 177 | } |
178 | 178 | ||
179 | QCString firstPart(strRep_.left(split)); | 179 | Q3CString firstPart(strRep_.left(split)); |
180 | QCString valuePart(strRep_.mid(split + 1)); | 180 | Q3CString valuePart(strRep_.mid(split + 1)); |
181 | 181 | ||
182 | split = firstPart.find('.'); | 182 | split = firstPart.find('.'); |
183 | 183 | ||
184 | if (split != -1) { | 184 | if (split != -1) { |
185 | group_ = firstPart.left(split); | 185 | group_ = firstPart.left(split); |
186 | firstPart= firstPart.mid(split + 1); | 186 | firstPart= firstPart.mid(split + 1); |
187 | } | 187 | } |
188 | 188 | ||
189 | vDebug("Group == " + group_); | 189 | vDebug("Group == " + group_); |
190 | vDebug("firstPart == " + firstPart); | 190 | vDebug("firstPart == " + firstPart); |
191 | vDebug("valuePart == " + valuePart); | 191 | vDebug("valuePart == " + valuePart); |
192 | 192 | ||
193 | // Now we have the group, the name and param list together and the value. | 193 | // Now we have the group, the name and param list together and the value. |
194 | 194 | ||
195 | QStrList l; | 195 | Q3StrList l; |
196 | 196 | ||
197 | RTokenise(firstPart, ";", l); | 197 | RTokenise(firstPart, ";", l); |
198 | 198 | ||
199 | if (l.count() == 0) {// invalid - no name ! | 199 | if (l.count() == 0) {// invalid - no name ! |
200 | vDebug("No name for this content line !"); | 200 | vDebug("No name for this content line !"); |
201 | return; | 201 | return; |
202 | } | 202 | } |
203 | 203 | ||
204 | name_ = l.at(0); | 204 | name_ = l.at(0); |
205 | 205 | ||
206 | // Now we have the name, so the rest of 'l' is the params. | 206 | // Now we have the name, so the rest of 'l' is the params. |
207 | // Remove the name part. | 207 | // Remove the name part. |
208 | l.remove(0u); | 208 | l.remove(0u); |
209 | 209 | ||
210 | entityType_= EntityNameToEntityType(name_); | 210 | entityType_= EntityNameToEntityType(name_); |
211 | paramType_= EntityTypeToParamType(entityType_); | 211 | paramType_= EntityTypeToParamType(entityType_); |
212 | 212 | ||
213 | unsigned int i = 0; | 213 | unsigned int i = 0; |
214 | 214 | ||
215 | // For each parameter, create a new parameter of the correct type. | 215 | // For each parameter, create a new parameter of the correct type. |
216 | 216 | ||
217 | QStrListIterator it(l); | 217 | Q3StrListIterator it(l); |
218 | 218 | ||
219 | for (; it.current(); ++it, i++) { | 219 | for (; it.current(); ++it, i++) { |
220 | 220 | ||
221 | QCString str = *it; | 221 | Q3CString str = *it; |
222 | 222 | ||
223 | split = str.find("="); | 223 | split = str.find("="); |
224 | if (split < 0 ) { | 224 | if (split < 0 ) { |
225 | vDebug("No '=' in paramter."); | 225 | vDebug("No '=' in paramter."); |
226 | continue; | 226 | continue; |
227 | } | 227 | } |
228 | 228 | ||
229 | QCString paraName = str.left(split); | 229 | Q3CString paraName = str.left(split); |
230 | QCString paraValue = str.mid(split + 1); | 230 | Q3CString paraValue = str.mid(split + 1); |
231 | 231 | ||
232 | QStrList paraValues; | 232 | Q3StrList paraValues; |
233 | RTokenise(paraValue, ",", paraValues); | 233 | RTokenise(paraValue, ",", paraValues); |
234 | 234 | ||
235 | QStrListIterator it2( paraValues ); | 235 | Q3StrListIterator it2( paraValues ); |
236 | 236 | ||
237 | for(; it2.current(); ++it2) { | 237 | for(; it2.current(); ++it2) { |
238 | 238 | ||
239 | Param *p = new Param; | 239 | Param *p = new Param; |
240 | p->setName( paraName ); | 240 | p->setName( paraName ); |
241 | p->setValue( *it2 ); | 241 | p->setValue( *it2 ); |
242 | 242 | ||
243 | paramList_.append(p); | 243 | paramList_.append(p); |
244 | } | 244 | } |
245 | } | 245 | } |
246 | 246 | ||
247 | // Create a new value of the correct type. | 247 | // Create a new value of the correct type. |
248 | 248 | ||
249 | valueType_ = EntityTypeToValueType(entityType_); | 249 | valueType_ = EntityTypeToValueType(entityType_); |
250 | 250 | ||
251 | //kdDebug(5710) << "valueType: " << valueType_ << endl; | 251 | //kdDebug(5710) << "valueType: " << valueType_ << endl; |
252 | 252 | ||
253 | switch (valueType_) { | 253 | switch (valueType_) { |
254 | 254 | ||
255 | case ValueSound: value_ = new SoundValue;break; | 255 | case ValueSound: value_ = new SoundValue;break; |
256 | case ValueAgent: value_ = new AgentValue;break; | 256 | case ValueAgent: value_ = new AgentValue;break; |
257 | case ValueAddress: value_ = new AdrValue; break; | 257 | case ValueAddress: value_ = new AdrValue; break; |
258 | case ValueTel: value_ = new TelValue; break; | 258 | case ValueTel: value_ = new TelValue; break; |
259 | case ValueTextBin: value_ = new TextBinValue;break; | 259 | case ValueTextBin: value_ = new TextBinValue;break; |
260 | case ValueOrg: value_ = new OrgValue; break; | 260 | case ValueOrg: value_ = new OrgValue; break; |
261 | case ValueN: value_ = new NValue; break; | 261 | case ValueN: value_ = new NValue; break; |
262 | case ValueUTC: value_ = new UTCValue; break; | 262 | case ValueUTC: value_ = new UTCValue; break; |
263 | case ValueURI: value_ = new URIValue; break; | 263 | case ValueURI: value_ = new URIValue; break; |
264 | case ValueClass: value_ = new ClassValue;break; | 264 | case ValueClass: value_ = new ClassValue;break; |
265 | case ValueFloat: value_ = new FloatValue;break; | 265 | case ValueFloat: value_ = new FloatValue;break; |
266 | case ValueImage: value_ = new ImageValue;break; | 266 | case ValueImage: value_ = new ImageValue;break; |
267 | case ValueDate: value_ = new DateValue; break; | 267 | case ValueDate: value_ = new DateValue; break; |
268 | case ValueTextList: value_ = new TextListValue;break; | 268 | case ValueTextList: value_ = new TextListValue;break; |
269 | case ValueGeo: value_ = new GeoValue; break; | 269 | case ValueGeo: value_ = new GeoValue; break; |
270 | case ValueText: | 270 | case ValueText: |
271 | case ValueUnknown: | 271 | case ValueUnknown: |
272 | default: value_ = new TextValue; break; | 272 | default: value_ = new TextValue; break; |
273 | } | 273 | } |
274 | 274 | ||
275 | *value_ = valuePart; | 275 | *value_ = valuePart; |
276 | } | 276 | } |
277 | 277 | ||
278 | void | 278 | void |
279 | ContentLine::_assemble() | 279 | ContentLine::_assemble() |
280 | { | 280 | { |
281 | //strRep_.truncate(0); | 281 | //strRep_.truncate(0); |
282 | QString line; | 282 | QString line; |
283 | if (!group_.isEmpty()) | 283 | if (!group_.isEmpty()) |
284 | line = group_ + '.'; | 284 | line = group_ + '.'; |
285 | line += name_; | 285 | line += name_; |
286 | ParamListIterator it(paramList_); | 286 | ParamListIterator it(paramList_); |
287 | for (; it.current(); ++it) | 287 | for (; it.current(); ++it) |
288 | line += ";" + it.current()->asString(); | 288 | line += ";" + it.current()->asString(); |
289 | 289 | ||
290 | if (value_ != 0) | 290 | if (value_ != 0) |
291 | line += ":" + value_->asString(); | 291 | line += ":" + value_->asString(); |
292 | 292 | ||
293 | line = line.replace( QRegExp( "\r" ), "\\r" ); | 293 | line = line.replace( QRegExp( "\r" ), "\\r" ); |
294 | line = line.replace( QRegExp( "\n" ), "\\n" ); | 294 | line = line.replace( QRegExp( "\n" ), "\\n" ); |
295 | 295 | ||
296 | // Fold lines longer than 72 chars | 296 | // Fold lines longer than 72 chars |
297 | const int maxLen = 72; | 297 | const int maxLen = 72; |
298 | uint cursor = 0; | 298 | uint cursor = 0; |
299 | QString cut; | 299 | QString cut; |
300 | while( line.length() > ( cursor + 1 ) * maxLen ) { | 300 | while( line.length() > ( cursor + 1 ) * maxLen ) { |
301 | cut += line.mid( cursor * maxLen, maxLen ); | 301 | cut += line.mid( cursor * maxLen, maxLen ); |
302 | cut += "\r\n "; | 302 | cut += "\r\n "; |
303 | ++cursor; | 303 | ++cursor; |
304 | } | 304 | } |
305 | cut += line.mid( cursor * maxLen ); | 305 | cut += line.mid( cursor * maxLen ); |
306 | strRep_ = cut.latin1(); | 306 | strRep_ = cut.latin1(); |
307 | //qDebug("ContentLine::_assemble()\n%s*****", strRep_.data()); | 307 | //qDebug("ContentLine::_assemble()\n%s*****", strRep_.data()); |
308 | #if 0 | 308 | #if 0 |
309 | vDebug("Assemble (argl) - my name is \"" + name_ + "\""); | 309 | vDebug("Assemble (argl) - my name is \"" + name_ + "\""); |
310 | strRep_.truncate(0); | 310 | strRep_.truncate(0); |
311 | 311 | ||
312 | QCString line; | 312 | Q3CString line; |
313 | 313 | ||
314 | if (!group_.isEmpty()) | 314 | if (!group_.isEmpty()) |
315 | line += group_ + '.'; | 315 | line += group_ + '.'; |
316 | 316 | ||
317 | line += name_; | 317 | line += name_; |
318 | 318 | ||
319 | vDebug("Adding parameters"); | 319 | vDebug("Adding parameters"); |
320 | ParamListIterator it(paramList_); | 320 | ParamListIterator it(paramList_); |
321 | 321 | ||
322 | for (; it.current(); ++it) | 322 | for (; it.current(); ++it) |
323 | line += ";" + it.current()->asString(); | 323 | line += ";" + it.current()->asString(); |
324 | 324 | ||
325 | vDebug("Adding value"); | 325 | vDebug("Adding value"); |
326 | if (value_ != 0) | 326 | if (value_ != 0) |
327 | line += ":" + value_->asString(); | 327 | line += ":" + value_->asString(); |
328 | else | 328 | else |
329 | vDebug("No value"); | 329 | vDebug("No value"); |
330 | 330 | ||
331 | // Quote newlines | 331 | // Quote newlines |
332 | line = line.replace( QRegExp( "\n" ), "\\n" ); | 332 | line = line.replace( QRegExp( "\n" ), "\\n" ); |
333 | 333 | ||
334 | // Fold lines longer than 72 chars | 334 | // Fold lines longer than 72 chars |
335 | const int maxLen = 72; | 335 | const int maxLen = 72; |
336 | uint cursor = 0; | 336 | uint cursor = 0; |
337 | while( line.length() > ( cursor + 1 ) * maxLen ) { | 337 | while( line.length() > ( cursor + 1 ) * maxLen ) { |
338 | strRep_ += line.mid( cursor * maxLen, maxLen ); | 338 | strRep_ += line.mid( cursor * maxLen, maxLen ); |
339 | strRep_ += "\r\n "; | 339 | strRep_ += "\r\n "; |
340 | ++cursor; | 340 | ++cursor; |
341 | } | 341 | } |
342 | strRep_ += line.mid( cursor * maxLen ); | 342 | strRep_ += line.mid( cursor * maxLen ); |
343 | qDebug("ContentLine::_assemble()\n%s*****", strRep_.data()); | 343 | qDebug("ContentLine::_assemble()\n%s*****", strRep_.data()); |
344 | #endif | 344 | #endif |
345 | } | 345 | } |
346 | 346 | ||
347 | void | 347 | void |
348 | ContentLine::clear() | 348 | ContentLine::clear() |
349 | { | 349 | { |
350 | group_.truncate(0); | 350 | group_.truncate(0); |
351 | name_.truncate(0); | 351 | name_.truncate(0); |
352 | paramList_.clear(); | 352 | paramList_.clear(); |
353 | delete value_; | 353 | delete value_; |
354 | value_ = 0; | 354 | value_ = 0; |
355 | } | 355 | } |
diff --git a/kabc/vcard/DateParam.cpp b/kabc/vcard/DateParam.cpp index 52af089..52fb828 100644 --- a/kabc/vcard/DateParam.cpp +++ b/kabc/vcard/DateParam.cpp | |||
@@ -1,82 +1,84 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardDateParam.h> | 24 | #include <VCardDateParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | DateParam::DateParam() | 32 | DateParam::DateParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | DateParam::DateParam(const DateParam & x) | 37 | DateParam::DateParam(const DateParam & x) |
36 | :Param(x) | 38 | :Param(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | DateParam::DateParam(const QCString & s) | 42 | DateParam::DateParam(const Q3CString & s) |
41 | :Param(s) | 43 | :Param(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | DateParam & | 47 | DateParam & |
46 | DateParam::operator = (DateParam & x) | 48 | DateParam::operator = (DateParam & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Param::operator = (x); | 52 | Param::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | DateParam & | 56 | DateParam & |
55 | DateParam::operator = (const QCString & s) | 57 | DateParam::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Param::operator = (s); | 59 | Param::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | DateParam::operator == (DateParam & x) | 64 | DateParam::operator == (DateParam & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | 67 | ||
66 | return false; | 68 | return false; |
67 | } | 69 | } |
68 | 70 | ||
69 | DateParam::~DateParam() | 71 | DateParam::~DateParam() |
70 | { | 72 | { |
71 | } | 73 | } |
72 | 74 | ||
73 | void | 75 | void |
74 | DateParam::_parse() | 76 | DateParam::_parse() |
75 | { | 77 | { |
76 | } | 78 | } |
77 | 79 | ||
78 | void | 80 | void |
79 | DateParam::_assemble() | 81 | DateParam::_assemble() |
80 | { | 82 | { |
81 | } | 83 | } |
82 | 84 | ||
diff --git a/kabc/vcard/DateValue.cpp b/kabc/vcard/DateValue.cpp index c5c5c85..87c7007 100644 --- a/kabc/vcard/DateValue.cpp +++ b/kabc/vcard/DateValue.cpp | |||
@@ -1,344 +1,346 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qregexp.h> | 24 | #include <qregexp.h> |
25 | //Added by qt3to4: | ||
26 | #include <Q3CString> | ||
25 | 27 | ||
26 | #include <kdebug.h> | 28 | #include <kdebug.h> |
27 | 29 | ||
28 | #include <VCardDefines.h> | 30 | #include <VCardDefines.h> |
29 | #include <VCardDateValue.h> | 31 | #include <VCardDateValue.h> |
30 | #include <VCardValue.h> | 32 | #include <VCardValue.h> |
31 | 33 | ||
32 | using namespace VCARD; | 34 | using namespace VCARD; |
33 | 35 | ||
34 | DateValue::DateValue() | 36 | DateValue::DateValue() |
35 | :Value() | 37 | :Value() |
36 | { | 38 | { |
37 | vDebug("DateValue::DateValue()"); | 39 | vDebug("DateValue::DateValue()"); |
38 | } | 40 | } |
39 | 41 | ||
40 | DateValue::DateValue( | 42 | DateValue::DateValue( |
41 | unsigned intyear, | 43 | unsigned intyear, |
42 | unsigned intmonth, | 44 | unsigned intmonth, |
43 | unsigned intday, | 45 | unsigned intday, |
44 | unsigned inthour, | 46 | unsigned inthour, |
45 | unsigned intminute, | 47 | unsigned intminute, |
46 | unsigned intsecond, | 48 | unsigned intsecond, |
47 | double secFrac, | 49 | double secFrac, |
48 | bool zonePositive, | 50 | bool zonePositive, |
49 | unsigned intzoneHour, | 51 | unsigned intzoneHour, |
50 | unsigned intzoneMinute) | 52 | unsigned intzoneMinute) |
51 | : Value (), | 53 | : Value (), |
52 | year_ (year), | 54 | year_ (year), |
53 | month_ (month), | 55 | month_ (month), |
54 | day_ (day), | 56 | day_ (day), |
55 | hour_ (hour), | 57 | hour_ (hour), |
56 | minute_ (minute), | 58 | minute_ (minute), |
57 | second_ (second), | 59 | second_ (second), |
58 | zoneHour_ (zoneHour), | 60 | zoneHour_ (zoneHour), |
59 | zoneMinute_ (zoneMinute), | 61 | zoneMinute_ (zoneMinute), |
60 | secFrac_ (secFrac), | 62 | secFrac_ (secFrac), |
61 | zonePositive_(zonePositive), | 63 | zonePositive_(zonePositive), |
62 | hasTime_(true) | 64 | hasTime_(true) |
63 | { | 65 | { |
64 | parsed_ = true; | 66 | parsed_ = true; |
65 | assembled_ = false; | 67 | assembled_ = false; |
66 | } | 68 | } |
67 | 69 | ||
68 | DateValue::DateValue(const QDate & d) | 70 | DateValue::DateValue(const QDate & d) |
69 | : Value (), | 71 | : Value (), |
70 | year_ (d.year()), | 72 | year_ (d.year()), |
71 | month_ (d.month()), | 73 | month_ (d.month()), |
72 | day_ (d.day()), | 74 | day_ (d.day()), |
73 | hasTime_(false) | 75 | hasTime_(false) |
74 | { | 76 | { |
75 | parsed_ = true; | 77 | parsed_ = true; |
76 | assembled_ = false; | 78 | assembled_ = false; |
77 | } | 79 | } |
78 | 80 | ||
79 | DateValue::DateValue(const QDateTime & d) | 81 | DateValue::DateValue(const QDateTime & d) |
80 | : Value (), | 82 | : Value (), |
81 | year_ (d.date().year()), | 83 | year_ (d.date().year()), |
82 | month_ (d.date().month()), | 84 | month_ (d.date().month()), |
83 | day_ (d.date().day()), | 85 | day_ (d.date().day()), |
84 | hour_ (d.time().hour()), | 86 | hour_ (d.time().hour()), |
85 | minute_ (d.time().minute()), | 87 | minute_ (d.time().minute()), |
86 | second_ (d.time().second()), | 88 | second_ (d.time().second()), |
87 | hasTime_(true) | 89 | hasTime_(true) |
88 | { | 90 | { |
89 | parsed_ = true; | 91 | parsed_ = true; |
90 | assembled_ = false; | 92 | assembled_ = false; |
91 | } | 93 | } |
92 | 94 | ||
93 | DateValue::DateValue(const DateValue & x) | 95 | DateValue::DateValue(const DateValue & x) |
94 | :Value(x) | 96 | :Value(x) |
95 | { | 97 | { |
96 | year_ = x.year_; | 98 | year_ = x.year_; |
97 | month_ = x.month_; | 99 | month_ = x.month_; |
98 | day_ = x.day_; | 100 | day_ = x.day_; |
99 | hour_ = x.hour_; | 101 | hour_ = x.hour_; |
100 | minute_ = x.minute_; | 102 | minute_ = x.minute_; |
101 | second_ = x.second_; | 103 | second_ = x.second_; |
102 | zoneHour_ = x.zoneHour_; | 104 | zoneHour_ = x.zoneHour_; |
103 | zoneMinute_ = x.zoneMinute_; | 105 | zoneMinute_ = x.zoneMinute_; |
104 | secFrac_ = x.secFrac_; | 106 | secFrac_ = x.secFrac_; |
105 | hasTime_ = x.hasTime_; | 107 | hasTime_ = x.hasTime_; |
106 | } | 108 | } |
107 | 109 | ||
108 | DateValue::DateValue(const QCString & s) | 110 | DateValue::DateValue(const Q3CString & s) |
109 | :Value(s) | 111 | :Value(s) |
110 | { | 112 | { |
111 | } | 113 | } |
112 | 114 | ||
113 | DateValue & | 115 | DateValue & |
114 | DateValue::operator = (DateValue & x) | 116 | DateValue::operator = (DateValue & x) |
115 | { | 117 | { |
116 | if (*this == x) return *this; | 118 | if (*this == x) return *this; |
117 | 119 | ||
118 | Value::operator = (x); | 120 | Value::operator = (x); |
119 | return *this; | 121 | return *this; |
120 | } | 122 | } |
121 | 123 | ||
122 | DateValue & | 124 | DateValue & |
123 | DateValue::operator = (const QCString & s) | 125 | DateValue::operator = (const Q3CString & s) |
124 | { | 126 | { |
125 | Value::operator = (s); | 127 | Value::operator = (s); |
126 | return *this; | 128 | return *this; |
127 | } | 129 | } |
128 | 130 | ||
129 | bool | 131 | bool |
130 | DateValue::operator == (DateValue & x) | 132 | DateValue::operator == (DateValue & x) |
131 | { | 133 | { |
132 | x.parse(); | 134 | x.parse(); |
133 | return false; | 135 | return false; |
134 | } | 136 | } |
135 | 137 | ||
136 | DateValue::~DateValue() | 138 | DateValue::~DateValue() |
137 | { | 139 | { |
138 | } | 140 | } |
139 | 141 | ||
140 | DateValue * | 142 | DateValue * |
141 | DateValue::clone() | 143 | DateValue::clone() |
142 | { | 144 | { |
143 | return new DateValue( *this ); | 145 | return new DateValue( *this ); |
144 | } | 146 | } |
145 | 147 | ||
146 | void | 148 | void |
147 | DateValue::_parse() | 149 | DateValue::_parse() |
148 | { | 150 | { |
149 | vDebug("DateValue::_parse()"); | 151 | vDebug("DateValue::_parse()"); |
150 | 152 | ||
151 | // date = date-full-year ["-"] date-month ["-"] date-mday | 153 | // date = date-full-year ["-"] date-month ["-"] date-mday |
152 | // time = time-hour [":"] time-minute [":"] time-second [":"] | 154 | // time = time-hour [":"] time-minute [":"] time-second [":"] |
153 | // [time-secfrac] [time-zone] | 155 | // [time-secfrac] [time-zone] |
154 | 156 | ||
155 | int timeSep = strRep_.find('T'); | 157 | int timeSep = strRep_.find('T'); |
156 | 158 | ||
157 | QCString dateStr; | 159 | Q3CString dateStr; |
158 | QCString timeStr; | 160 | Q3CString timeStr; |
159 | 161 | ||
160 | if (timeSep == -1) { | 162 | if (timeSep == -1) { |
161 | 163 | ||
162 | dateStr = strRep_; | 164 | dateStr = strRep_; |
163 | vDebug("Has date string \"" + dateStr + "\""); | 165 | vDebug("Has date string \"" + dateStr + "\""); |
164 | 166 | ||
165 | } else { | 167 | } else { |
166 | 168 | ||
167 | dateStr = strRep_.left(timeSep); | 169 | dateStr = strRep_.left(timeSep); |
168 | vDebug("Has date string \"" + dateStr + "\""); | 170 | vDebug("Has date string \"" + dateStr + "\""); |
169 | 171 | ||
170 | timeStr = strRep_.mid(timeSep + 1); | 172 | timeStr = strRep_.mid(timeSep + 1); |
171 | vDebug("Has time string \"" + timeStr + "\""); | 173 | vDebug("Has time string \"" + timeStr + "\""); |
172 | } | 174 | } |
173 | 175 | ||
174 | /////////////////////////////////////////////////////////////// DATE | 176 | /////////////////////////////////////////////////////////////// DATE |
175 | 177 | ||
176 | dateStr.replace(QRegExp("-"), ""); | 178 | dateStr.replace("-", ""); |
177 | 179 | ||
178 | kdDebug(5710) << "dateStr: " << dateStr << endl; | 180 | kdDebug(5710) << "dateStr: " << dateStr << endl; |
179 | 181 | ||
180 | year_= dateStr.left(4).toInt(); | 182 | year_= dateStr.left(4).toInt(); |
181 | month_= dateStr.mid(4, 2).toInt(); | 183 | month_= dateStr.mid(4, 2).toInt(); |
182 | day_= dateStr.right(2).toInt(); | 184 | day_= dateStr.right(2).toInt(); |
183 | 185 | ||
184 | if (timeSep == -1) { | 186 | if (timeSep == -1) { |
185 | hasTime_ = false; | 187 | hasTime_ = false; |
186 | return; // No time, done. | 188 | return; // No time, done. |
187 | } | 189 | } |
188 | else | 190 | else |
189 | hasTime_ = true; | 191 | hasTime_ = true; |
190 | 192 | ||
191 | /////////////////////////////////////////////////////////////// TIME | 193 | /////////////////////////////////////////////////////////////// TIME |
192 | 194 | ||
193 | /////////////////////////////////////////////////////////////// ZONE | 195 | /////////////////////////////////////////////////////////////// ZONE |
194 | 196 | ||
195 | int zoneSep = timeStr.find('Z'); | 197 | int zoneSep = timeStr.find('Z'); |
196 | 198 | ||
197 | if (zoneSep != -1 && timeStr.length() - zoneSep > 3) { | 199 | if (zoneSep != -1 && timeStr.length() - zoneSep > 3) { |
198 | 200 | ||
199 | QCString zoneStr(timeStr.mid(zoneSep + 1)); | 201 | Q3CString zoneStr(timeStr.mid(zoneSep + 1)); |
200 | vDebug("zoneStr == " + zoneStr); | 202 | vDebug("zoneStr == " + zoneStr); |
201 | 203 | ||
202 | zonePositive_= (zoneStr[0] == '+'); | 204 | zonePositive_= (zoneStr[0] == '+'); |
203 | zoneHour_ = zoneStr.mid(1, 2).toInt(); | 205 | zoneHour_ = zoneStr.mid(1, 2).toInt(); |
204 | zoneMinute_ = zoneStr.right(2).toInt(); | 206 | zoneMinute_ = zoneStr.right(2).toInt(); |
205 | 207 | ||
206 | timeStr.remove(zoneSep, timeStr.length() - zoneSep); | 208 | timeStr.remove(zoneSep, timeStr.length() - zoneSep); |
207 | } | 209 | } |
208 | 210 | ||
209 | //////////////////////////////////////////////////// SECOND FRACTION | 211 | //////////////////////////////////////////////////// SECOND FRACTION |
210 | 212 | ||
211 | int secFracSep = timeStr.findRev(','); | 213 | int secFracSep = timeStr.findRev(','); |
212 | 214 | ||
213 | if (secFracSep != -1 && zoneSep != -1) { // zoneSep checked to avoid errors. | 215 | if (secFracSep != -1 && zoneSep != -1) { // zoneSep checked to avoid errors. |
214 | QCString quirkafleeg = "0." + timeStr.mid(secFracSep + 1, zoneSep); | 216 | Q3CString quirkafleeg = "0." + timeStr.mid(secFracSep + 1, zoneSep); |
215 | secFrac_ = quirkafleeg.toDouble(); | 217 | secFrac_ = quirkafleeg.toDouble(); |
216 | } | 218 | } |
217 | 219 | ||
218 | /////////////////////////////////////////////////////////////// HMS | 220 | /////////////////////////////////////////////////////////////// HMS |
219 | 221 | ||
220 | timeStr.replace(QRegExp(":"), ""); | 222 | timeStr.replace(":", ""); |
221 | 223 | ||
222 | hour_= timeStr.left(2).toInt(); | 224 | hour_= timeStr.left(2).toInt(); |
223 | minute_= timeStr.mid(2, 2).toInt(); | 225 | minute_= timeStr.mid(2, 2).toInt(); |
224 | second_= timeStr.mid(4, 2).toInt(); | 226 | second_= timeStr.mid(4, 2).toInt(); |
225 | } | 227 | } |
226 | 228 | ||
227 | void | 229 | void |
228 | DateValue::_assemble() | 230 | DateValue::_assemble() |
229 | { | 231 | { |
230 | vDebug("DateValue::_assemble"); | 232 | vDebug("DateValue::_assemble"); |
231 | 233 | ||
232 | QCString year; | 234 | Q3CString year; |
233 | QCString month; | 235 | Q3CString month; |
234 | QCString day; | 236 | Q3CString day; |
235 | 237 | ||
236 | year.setNum( year_ ); | 238 | year.setNum( year_ ); |
237 | month.setNum( month_ ); | 239 | month.setNum( month_ ); |
238 | day.setNum( day_ ); | 240 | day.setNum( day_ ); |
239 | 241 | ||
240 | if ( month.length() < 2 ) month.prepend( "0" ); | 242 | if ( month.length() < 2 ) month.prepend( "0" ); |
241 | if ( day.length() < 2 ) day.prepend( "0" ); | 243 | if ( day.length() < 2 ) day.prepend( "0" ); |
242 | 244 | ||
243 | strRep_ = year + '-' + month + '-' + day; | 245 | strRep_ = year + '-' + month + '-' + day; |
244 | 246 | ||
245 | if ( hasTime_ ) { | 247 | if ( hasTime_ ) { |
246 | QCString hour; | 248 | Q3CString hour; |
247 | QCString minute; | 249 | Q3CString minute; |
248 | QCString second; | 250 | Q3CString second; |
249 | 251 | ||
250 | hour.setNum( hour_ ); | 252 | hour.setNum( hour_ ); |
251 | minute.setNum( minute_ ); | 253 | minute.setNum( minute_ ); |
252 | second.setNum( second_ ); | 254 | second.setNum( second_ ); |
253 | 255 | ||
254 | if ( hour.length() < 2 ) hour.prepend( "0" ); | 256 | if ( hour.length() < 2 ) hour.prepend( "0" ); |
255 | if ( minute.length() < 2 ) minute.prepend( "0" ); | 257 | if ( minute.length() < 2 ) minute.prepend( "0" ); |
256 | if ( second.length() < 2 ) second.prepend( "0" ); | 258 | if ( second.length() < 2 ) second.prepend( "0" ); |
257 | 259 | ||
258 | strRep_ += 'T' + hour + ':' + minute + ':' + second + 'Z'; | 260 | strRep_ += 'T' + hour + ':' + minute + ':' + second + 'Z'; |
259 | } | 261 | } |
260 | } | 262 | } |
261 | 263 | ||
262 | unsigned int | 264 | unsigned int |
263 | DateValue::year() | 265 | DateValue::year() |
264 | { | 266 | { |
265 | parse(); | 267 | parse(); |
266 | return year_; | 268 | return year_; |
267 | } | 269 | } |
268 | 270 | ||
269 | unsigned int | 271 | unsigned int |
270 | DateValue::month() | 272 | DateValue::month() |
271 | { | 273 | { |
272 | parse(); | 274 | parse(); |
273 | return month_; | 275 | return month_; |
274 | } | 276 | } |
275 | 277 | ||
276 | unsigned int | 278 | unsigned int |
277 | DateValue::day() | 279 | DateValue::day() |
278 | { | 280 | { |
279 | parse(); | 281 | parse(); |
280 | return day_; | 282 | return day_; |
281 | } | 283 | } |
282 | unsigned int | 284 | unsigned int |
283 | DateValue::hour() | 285 | DateValue::hour() |
284 | { | 286 | { |
285 | parse(); | 287 | parse(); |
286 | return hour_; | 288 | return hour_; |
287 | } | 289 | } |
288 | 290 | ||
289 | unsigned int | 291 | unsigned int |
290 | DateValue::minute() | 292 | DateValue::minute() |
291 | { | 293 | { |
292 | parse(); | 294 | parse(); |
293 | return minute_; | 295 | return minute_; |
294 | } | 296 | } |
295 | 297 | ||
296 | unsigned int | 298 | unsigned int |
297 | DateValue::second() | 299 | DateValue::second() |
298 | { | 300 | { |
299 | parse(); | 301 | parse(); |
300 | return second_; | 302 | return second_; |
301 | } | 303 | } |
302 | 304 | ||
303 | double | 305 | double |
304 | DateValue::secondFraction() | 306 | DateValue::secondFraction() |
305 | { | 307 | { |
306 | parse(); | 308 | parse(); |
307 | return secFrac_; | 309 | return secFrac_; |
308 | } | 310 | } |
309 | 311 | ||
310 | bool | 312 | bool |
311 | DateValue::zonePositive() | 313 | DateValue::zonePositive() |
312 | { | 314 | { |
313 | parse(); | 315 | parse(); |
314 | return zonePositive_; | 316 | return zonePositive_; |
315 | } | 317 | } |
316 | 318 | ||
317 | unsigned int | 319 | unsigned int |
318 | DateValue::zoneHour() | 320 | DateValue::zoneHour() |
319 | { | 321 | { |
320 | parse(); | 322 | parse(); |
321 | return zoneHour_; | 323 | return zoneHour_; |
322 | } | 324 | } |
323 | 325 | ||
324 | unsigned int | 326 | unsigned int |
325 | DateValue::zoneMinute() | 327 | DateValue::zoneMinute() |
326 | { | 328 | { |
327 | parse(); | 329 | parse(); |
328 | return zoneMinute_; | 330 | return zoneMinute_; |
329 | } | 331 | } |
330 | 332 | ||
331 | void | 333 | void |
332 | DateValue::setYear(unsigned int i) | 334 | DateValue::setYear(unsigned int i) |
333 | { | 335 | { |
334 | year_ = i; | 336 | year_ = i; |
335 | assembled_ = false; | 337 | assembled_ = false; |
336 | } | 338 | } |
337 | 339 | ||
338 | void | 340 | void |
339 | DateValue::setMonth(unsigned int i) | 341 | DateValue::setMonth(unsigned int i) |
340 | { | 342 | { |
341 | month_ = i; | 343 | month_ = i; |
342 | assembled_ = false; | 344 | assembled_ = false; |
343 | } | 345 | } |
344 | 346 | ||
diff --git a/kabc/vcard/EmailParam.cpp b/kabc/vcard/EmailParam.cpp index 8c87477..877af60 100644 --- a/kabc/vcard/EmailParam.cpp +++ b/kabc/vcard/EmailParam.cpp | |||
@@ -1,116 +1,118 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardEmailParam.h> | 24 | #include <VCardEmailParam.h> |
25 | #include <VCardParam.h> | 25 | #include <VCardParam.h> |
26 | #include <VCardDefines.h> | 26 | #include <VCardDefines.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | EmailParam::EmailParam() | 32 | EmailParam::EmailParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | vDebug("ctor"); | 35 | vDebug("ctor"); |
34 | } | 36 | } |
35 | 37 | ||
36 | EmailParam::EmailParam(const EmailParam & x) | 38 | EmailParam::EmailParam(const EmailParam & x) |
37 | :Param(x), | 39 | :Param(x), |
38 | emailType_(x.emailType_), | 40 | emailType_(x.emailType_), |
39 | pref_ (x.pref_) | 41 | pref_ (x.pref_) |
40 | { | 42 | { |
41 | } | 43 | } |
42 | 44 | ||
43 | EmailParam::EmailParam(const QCString & s) | 45 | EmailParam::EmailParam(const Q3CString & s) |
44 | :Param(s) | 46 | :Param(s) |
45 | { | 47 | { |
46 | } | 48 | } |
47 | 49 | ||
48 | EmailParam & | 50 | EmailParam & |
49 | EmailParam::operator = (EmailParam & x) | 51 | EmailParam::operator = (EmailParam & x) |
50 | { | 52 | { |
51 | if (*this == x) return *this; | 53 | if (*this == x) return *this; |
52 | 54 | ||
53 | emailType_= x.emailType(); | 55 | emailType_= x.emailType(); |
54 | pref_ = x.pref_; | 56 | pref_ = x.pref_; |
55 | 57 | ||
56 | Param::operator = (x); | 58 | Param::operator = (x); |
57 | return *this; | 59 | return *this; |
58 | } | 60 | } |
59 | 61 | ||
60 | EmailParam & | 62 | EmailParam & |
61 | EmailParam::operator = (const QCString & s) | 63 | EmailParam::operator = (const Q3CString & s) |
62 | { | 64 | { |
63 | Param::operator = (s); | 65 | Param::operator = (s); |
64 | return *this; | 66 | return *this; |
65 | } | 67 | } |
66 | 68 | ||
67 | bool | 69 | bool |
68 | EmailParam::operator == (EmailParam & x) | 70 | EmailParam::operator == (EmailParam & x) |
69 | { | 71 | { |
70 | parse(); | 72 | parse(); |
71 | 73 | ||
72 | if (pref_) | 74 | if (pref_) |
73 | return (x.pref_ && x.emailType() == emailType_); | 75 | return (x.pref_ && x.emailType() == emailType_); |
74 | 76 | ||
75 | return !x.pref(); | 77 | return !x.pref(); |
76 | } | 78 | } |
77 | 79 | ||
78 | EmailParam::~EmailParam() | 80 | EmailParam::~EmailParam() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
82 | void | 84 | void |
83 | EmailParam::_parse() | 85 | EmailParam::_parse() |
84 | { | 86 | { |
85 | #if 0 | 87 | #if 0 |
86 | Param::parseToList(); | 88 | Param::parseToList(); |
87 | 89 | ||
88 | SubParamListIterator it(subParamList_); | 90 | SubParamListIterator it(subParamList_); |
89 | 91 | ||
90 | pref_ = true; | 92 | pref_ = true; |
91 | emailType_ = ""; | 93 | emailType_ = ""; |
92 | 94 | ||
93 | for (; it.current(); ++it) { | 95 | for (; it.current(); ++it) { |
94 | 96 | ||
95 | if (qstricmp(it.current()->name(), "TYPE") == 0) { | 97 | if (qstricmp(it.current()->name(), "TYPE") == 0) { |
96 | emailType_ = it.current()->value(); | 98 | emailType_ = it.current()->value(); |
97 | continue; | 99 | continue; |
98 | } | 100 | } |
99 | 101 | ||
100 | if (qstricmp(it.current()->name(), "PREF") == 0) { | 102 | if (qstricmp(it.current()->name(), "PREF") == 0) { |
101 | pref_ = true; | 103 | pref_ = true; |
102 | } | 104 | } |
103 | } | 105 | } |
104 | #endif | 106 | #endif |
105 | } | 107 | } |
106 | 108 | ||
107 | void | 109 | void |
108 | EmailParam::_assemble() | 110 | EmailParam::_assemble() |
109 | { | 111 | { |
110 | strRep_ = "TYPE="; | 112 | strRep_ = "TYPE="; |
111 | strRep_ += emailType_; | 113 | strRep_ += emailType_; |
112 | 114 | ||
113 | if (pref_) | 115 | if (pref_) |
114 | strRep_ += ",PREF"; | 116 | strRep_ += ",PREF"; |
115 | } | 117 | } |
116 | 118 | ||
diff --git a/kabc/vcard/Entity.cpp b/kabc/vcard/Entity.cpp index b7d09e0..e38fa11 100644 --- a/kabc/vcard/Entity.cpp +++ b/kabc/vcard/Entity.cpp | |||
@@ -1,134 +1,136 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardEntity.h> | 24 | #include <VCardEntity.h> |
25 | //Added by qt3to4: | ||
26 | #include <Q3CString> | ||
25 | 27 | ||
26 | using namespace VCARD; | 28 | using namespace VCARD; |
27 | 29 | ||
28 | Entity::Entity() | 30 | Entity::Entity() |
29 | : parsed_ (false), | 31 | : parsed_ (false), |
30 | assembled_(true) | 32 | assembled_(true) |
31 | { | 33 | { |
32 | // empty | 34 | // empty |
33 | } | 35 | } |
34 | 36 | ||
35 | Entity::Entity(const Entity & e) | 37 | Entity::Entity(const Entity & e) |
36 | : strRep_ (e.strRep_), | 38 | : strRep_ (e.strRep_), |
37 | parsed_ (e.parsed_), | 39 | parsed_ (e.parsed_), |
38 | assembled_(e.assembled_) | 40 | assembled_(e.assembled_) |
39 | { | 41 | { |
40 | // empty | 42 | // empty |
41 | } | 43 | } |
42 | 44 | ||
43 | Entity::Entity(const QCString & s) | 45 | Entity::Entity(const Q3CString & s) |
44 | : strRep_ (s), | 46 | : strRep_ (s), |
45 | parsed_ (false), | 47 | parsed_ (false), |
46 | assembled_(true) | 48 | assembled_(true) |
47 | { | 49 | { |
48 | // empty | 50 | // empty |
49 | } | 51 | } |
50 | 52 | ||
51 | Entity & | 53 | Entity & |
52 | Entity::operator = (const Entity & e) | 54 | Entity::operator = (const Entity & e) |
53 | { | 55 | { |
54 | if (this == &e) return *this; | 56 | if (this == &e) return *this; |
55 | 57 | ||
56 | strRep_ = e.strRep_; | 58 | strRep_ = e.strRep_; |
57 | parsed_ = e.parsed_; | 59 | parsed_ = e.parsed_; |
58 | assembled_= e.assembled_; | 60 | assembled_= e.assembled_; |
59 | 61 | ||
60 | return *this; | 62 | return *this; |
61 | } | 63 | } |
62 | 64 | ||
63 | Entity & | 65 | Entity & |
64 | Entity::operator = (const QCString & s) | 66 | Entity::operator = (const Q3CString & s) |
65 | { | 67 | { |
66 | strRep_ = s; | 68 | strRep_ = s; |
67 | parsed_ = false; | 69 | parsed_ = false; |
68 | assembled_= true; | 70 | assembled_= true; |
69 | 71 | ||
70 | return *this; | 72 | return *this; |
71 | } | 73 | } |
72 | 74 | ||
73 | bool | 75 | bool |
74 | Entity::operator == (Entity & e) | 76 | Entity::operator == (Entity & e) |
75 | { | 77 | { |
76 | return asString() == e.asString(); | 78 | return asString() == e.asString(); |
77 | } | 79 | } |
78 | 80 | ||
79 | bool | 81 | bool |
80 | Entity::operator != (Entity & e) | 82 | Entity::operator != (Entity & e) |
81 | { | 83 | { |
82 | return !(*this == e); | 84 | return !(*this == e); |
83 | } | 85 | } |
84 | 86 | ||
85 | bool | 87 | bool |
86 | Entity::operator == (const QCString & s) | 88 | Entity::operator == (const Q3CString & s) |
87 | { | 89 | { |
88 | return asString() == s; | 90 | return asString() == s; |
89 | } | 91 | } |
90 | 92 | ||
91 | bool | 93 | bool |
92 | Entity::operator != (const QCString & s) | 94 | Entity::operator != (const Q3CString & s) |
93 | { | 95 | { |
94 | return !(*this == s); | 96 | return !(*this == s); |
95 | } | 97 | } |
96 | 98 | ||
97 | Entity::~Entity() | 99 | Entity::~Entity() |
98 | { | 100 | { |
99 | // empty | 101 | // empty |
100 | } | 102 | } |
101 | 103 | ||
102 | QCString | 104 | Q3CString |
103 | Entity::asString() | 105 | Entity::asString() |
104 | { | 106 | { |
105 | //vDebug("Entity::asString()"); | 107 | //vDebug("Entity::asString()"); |
106 | assemble(); | 108 | assemble(); |
107 | 109 | ||
108 | return strRep_; | 110 | return strRep_; |
109 | } | 111 | } |
110 | 112 | ||
111 | void | 113 | void |
112 | Entity::parse() | 114 | Entity::parse() |
113 | { | 115 | { |
114 | //vDebug( "Entity::parse()" ); | 116 | //vDebug( "Entity::parse()" ); |
115 | 117 | ||
116 | if (!parsed_) _parse(); | 118 | if (!parsed_) _parse(); |
117 | 119 | ||
118 | parsed_ = true; | 120 | parsed_ = true; |
119 | assembled_= false; | 121 | assembled_= false; |
120 | } | 122 | } |
121 | 123 | ||
122 | void | 124 | void |
123 | Entity::assemble() | 125 | Entity::assemble() |
124 | { | 126 | { |
125 | //vDebug( "Entity::assemble()" ); | 127 | //vDebug( "Entity::assemble()" ); |
126 | 128 | ||
127 | if (assembled_) return; | 129 | if (assembled_) return; |
128 | 130 | ||
129 | parse(); | 131 | parse(); |
130 | _assemble(); | 132 | _assemble(); |
131 | 133 | ||
132 | assembled_= true; | 134 | assembled_= true; |
133 | } | 135 | } |
134 | 136 | ||
diff --git a/kabc/vcard/Enum.cpp b/kabc/vcard/Enum.cpp index cc48b5a..036324c 100644 --- a/kabc/vcard/Enum.cpp +++ b/kabc/vcard/Enum.cpp | |||
@@ -1,329 +1,329 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qcstring.h> | 24 | #include <q3cstring.h> |
25 | #include <ctype.h> | 25 | #include <ctype.h> |
26 | 26 | ||
27 | #include <VCardEnum.h> | 27 | #include <VCardEnum.h> |
28 | 28 | ||
29 | using namespace VCARD; | 29 | using namespace VCARD; |
30 | 30 | ||
31 | // There are 31 possible types, not including extensions. | 31 | // There are 31 possible types, not including extensions. |
32 | const QCString | 32 | const Q3CString |
33 | VCARD::paramNames [] = | 33 | VCARD::paramNames [] = |
34 | { | 34 | { |
35 | "NAME", | 35 | "NAME", |
36 | "PROFILE", | 36 | "PROFILE", |
37 | "SOURCE", | 37 | "SOURCE", |
38 | "FN", | 38 | "FN", |
39 | "N", | 39 | "N", |
40 | "NICKNAME", | 40 | "NICKNAME", |
41 | "PHOTO", | 41 | "PHOTO", |
42 | "BDAY", | 42 | "BDAY", |
43 | "ADR", | 43 | "ADR", |
44 | "LABEL", | 44 | "LABEL", |
45 | "TEL", | 45 | "TEL", |
46 | "EMAIL", | 46 | "EMAIL", |
47 | "MAILER", | 47 | "MAILER", |
48 | "TZ", | 48 | "TZ", |
49 | "GEO", | 49 | "GEO", |
50 | "TITLE", | 50 | "TITLE", |
51 | "ROLE", | 51 | "ROLE", |
52 | "LOGO", | 52 | "LOGO", |
53 | "AGENT", | 53 | "AGENT", |
54 | "ORG", | 54 | "ORG", |
55 | "CATEGORIES", | 55 | "CATEGORIES", |
56 | "NOTE", | 56 | "NOTE", |
57 | "PRODID", | 57 | "PRODID", |
58 | "REV", | 58 | "REV", |
59 | "SORT-STRING", | 59 | "SORT-STRING", |
60 | "SOUND", | 60 | "SOUND", |
61 | "UID", | 61 | "UID", |
62 | "URL", | 62 | "URL", |
63 | "VERSION", | 63 | "VERSION", |
64 | "CLASS", | 64 | "CLASS", |
65 | "KEY" | 65 | "KEY" |
66 | }; | 66 | }; |
67 | 67 | ||
68 | const ParamType | 68 | const ParamType |
69 | VCARD::paramTypesTable[] = { | 69 | VCARD::paramTypesTable[] = { |
70 | ParamNone, // NAME | 70 | ParamNone, // NAME |
71 | ParamNone, // PROFILE | 71 | ParamNone, // PROFILE |
72 | ParamSource, // SOURCE | 72 | ParamSource, // SOURCE |
73 | ParamText, // FN | 73 | ParamText, // FN |
74 | ParamText, // N | 74 | ParamText, // N |
75 | ParamText, // NICKNAME | 75 | ParamText, // NICKNAME |
76 | ParamImage, // PHOTO (inline/refer) | 76 | ParamImage, // PHOTO (inline/refer) |
77 | ParamDate, // BDAY ("VALUE = "date-time/date) | 77 | ParamDate, // BDAY ("VALUE = "date-time/date) |
78 | ParamAddrText, // ADR (adr-param/text-param) | 78 | ParamAddrText, // ADR (adr-param/text-param) |
79 | ParamAddrText, // LABEL (adr-param/text-param) | 79 | ParamAddrText, // LABEL (adr-param/text-param) |
80 | ParamTel, // TEL | 80 | ParamTel, // TEL |
81 | ParamEmail, // EMAIL | 81 | ParamEmail, // EMAIL |
82 | ParamText, // MAILER | 82 | ParamText, // MAILER |
83 | ParamNone, // TZ | 83 | ParamNone, // TZ |
84 | ParamNone, // GEO | 84 | ParamNone, // GEO |
85 | ParamText, // TITLE | 85 | ParamText, // TITLE |
86 | ParamText, // ROLE | 86 | ParamText, // ROLE |
87 | ParamImage, // LOGO | 87 | ParamImage, // LOGO |
88 | ParamAgent, // AGENT | 88 | ParamAgent, // AGENT |
89 | ParamText, // ORG | 89 | ParamText, // ORG |
90 | ParamText, // CATEGORIES | 90 | ParamText, // CATEGORIES |
91 | ParamText, // NOTE | 91 | ParamText, // NOTE |
92 | ParamNone, // PRODID | 92 | ParamNone, // PRODID |
93 | ParamDate, // REV | 93 | ParamDate, // REV |
94 | ParamText, // SORT-STRING | 94 | ParamText, // SORT-STRING |
95 | ParamSound, // SOUND | 95 | ParamSound, // SOUND |
96 | ParamNone, // UID | 96 | ParamNone, // UID |
97 | ParamNone, // URL | 97 | ParamNone, // URL |
98 | ParamNone, // VERSION | 98 | ParamNone, // VERSION |
99 | ParamNone, // CLASS | 99 | ParamNone, // CLASS |
100 | ParamTextBin, // KEY | 100 | ParamTextBin, // KEY |
101 | ParamTextNS // X | 101 | ParamTextNS // X |
102 | }; | 102 | }; |
103 | 103 | ||
104 | ParamType | 104 | ParamType |
105 | VCARD::EntityTypeToParamType(EntityType e) | 105 | VCARD::EntityTypeToParamType(EntityType e) |
106 | { | 106 | { |
107 | ParamType t(ParamUnknown); | 107 | ParamType t(ParamUnknown); |
108 | 108 | ||
109 | switch (e) { | 109 | switch (e) { |
110 | 110 | ||
111 | //---------------------------------------------------------------// | 111 | //---------------------------------------------------------------// |
112 | case EntityAgent: t = ParamAgent; break; | 112 | case EntityAgent: t = ParamAgent; break; |
113 | //---------------------------------------------------------------// | 113 | //---------------------------------------------------------------// |
114 | case EntitySound: t = ParamSound; break; | 114 | case EntitySound: t = ParamSound; break; |
115 | //---------------------------------------------------------------// | 115 | //---------------------------------------------------------------// |
116 | case EntitySource: t = ParamSource;break; | 116 | case EntitySource: t = ParamSource;break; |
117 | //---------------------------------------------------------------// | 117 | //---------------------------------------------------------------// |
118 | case EntityTelephone: t = ParamTel; break; | 118 | case EntityTelephone: t = ParamTel; break; |
119 | //---------------------------------------------------------------// | 119 | //---------------------------------------------------------------// |
120 | case EntityEmail: t = ParamEmail; break; | 120 | case EntityEmail: t = ParamEmail; break; |
121 | //---------------------------------------------------------------// | 121 | //---------------------------------------------------------------// |
122 | case EntityKey: t = ParamTextBin;break; | 122 | case EntityKey: t = ParamTextBin;break; |
123 | //---------------------------------------------------------------// | 123 | //---------------------------------------------------------------// |
124 | case EntityExtension: t = ParamTextNS;break; | 124 | case EntityExtension: t = ParamTextNS;break; |
125 | //---------------------------------------------------------------// | 125 | //---------------------------------------------------------------// |
126 | case EntityAddress: | 126 | case EntityAddress: |
127 | case EntityLabel: t = ParamAddrText;break; | 127 | case EntityLabel: t = ParamAddrText;break; |
128 | //---------------------------------------------------------------// | 128 | //---------------------------------------------------------------// |
129 | case EntityBirthday: | 129 | case EntityBirthday: |
130 | case EntityRevision: t = ParamDate; break; | 130 | case EntityRevision: t = ParamDate; break; |
131 | //---------------------------------------------------------------// | 131 | //---------------------------------------------------------------// |
132 | case EntityPhoto: | 132 | case EntityPhoto: |
133 | case EntityLogo: t = ParamImage; break; | 133 | case EntityLogo: t = ParamImage; break; |
134 | //---------------------------------------------------------------// | 134 | //---------------------------------------------------------------// |
135 | case EntityOrganisation: | 135 | case EntityOrganisation: |
136 | case EntityTitle: | 136 | case EntityTitle: |
137 | case EntityRole: | 137 | case EntityRole: |
138 | case EntityFullName: | 138 | case EntityFullName: |
139 | case EntityMailer: | 139 | case EntityMailer: |
140 | case EntityN: | 140 | case EntityN: |
141 | case EntitySortString: | 141 | case EntitySortString: |
142 | case EntityNickname: | 142 | case EntityNickname: |
143 | case EntityCategories: | 143 | case EntityCategories: |
144 | case EntityNote: t = ParamText; break; | 144 | case EntityNote: t = ParamText; break; |
145 | //---------------------------------------------------------------// | 145 | //---------------------------------------------------------------// |
146 | case EntityProductID: | 146 | case EntityProductID: |
147 | case EntityTimeZone: | 147 | case EntityTimeZone: |
148 | case EntityUID: | 148 | case EntityUID: |
149 | case EntityURL: | 149 | case EntityURL: |
150 | case EntityClass: | 150 | case EntityClass: |
151 | case EntityGeo: | 151 | case EntityGeo: |
152 | case EntityName: | 152 | case EntityName: |
153 | case EntityVersion: | 153 | case EntityVersion: |
154 | case EntityProfile: | 154 | case EntityProfile: |
155 | default: t = ParamNone; break; | 155 | default: t = ParamNone; break; |
156 | //---------------------------------------------------------------// | 156 | //---------------------------------------------------------------// |
157 | 157 | ||
158 | } | 158 | } |
159 | 159 | ||
160 | return t; | 160 | return t; |
161 | } | 161 | } |
162 | 162 | ||
163 | ValueType | 163 | ValueType |
164 | VCARD::EntityTypeToValueType(EntityType e) | 164 | VCARD::EntityTypeToValueType(EntityType e) |
165 | { | 165 | { |
166 | ValueType t(ValueUnknown); | 166 | ValueType t(ValueUnknown); |
167 | 167 | ||
168 | switch (e) { | 168 | switch (e) { |
169 | 169 | ||
170 | //---------------------------------------------------------------// | 170 | //---------------------------------------------------------------// |
171 | case EntitySound: t = ValueSound; break; | 171 | case EntitySound: t = ValueSound; break; |
172 | //---------------------------------------------------------------// | 172 | //---------------------------------------------------------------// |
173 | case EntityAgent: t = ValueAgent; break; | 173 | case EntityAgent: t = ValueAgent; break; |
174 | //---------------------------------------------------------------// | 174 | //---------------------------------------------------------------// |
175 | case EntityAddress: t = ValueAddress;break; | 175 | case EntityAddress: t = ValueAddress;break; |
176 | //---------------------------------------------------------------// | 176 | //---------------------------------------------------------------// |
177 | case EntityTelephone: t = ValueTel; break; | 177 | case EntityTelephone: t = ValueTel; break; |
178 | //---------------------------------------------------------------// | 178 | //---------------------------------------------------------------// |
179 | case EntityKey: t = ValueTextBin;break; | 179 | case EntityKey: t = ValueTextBin;break; |
180 | //---------------------------------------------------------------// | 180 | //---------------------------------------------------------------// |
181 | case EntityOrganisation: t = ValueOrg; break; | 181 | case EntityOrganisation: t = ValueOrg; break; |
182 | //---------------------------------------------------------------// | 182 | //---------------------------------------------------------------// |
183 | case EntityN: t = ValueN; break; | 183 | case EntityN: t = ValueN; break; |
184 | //---------------------------------------------------------------// | 184 | //---------------------------------------------------------------// |
185 | case EntityTimeZone: t = ValueUTC; break; | 185 | case EntityTimeZone: t = ValueUTC; break; |
186 | //---------------------------------------------------------------// | 186 | //---------------------------------------------------------------// |
187 | case EntityClass: t = ValueClass; break; | 187 | case EntityClass: t = ValueClass; break; |
188 | //---------------------------------------------------------------// | 188 | //---------------------------------------------------------------// |
189 | case EntityGeo: t = ValueGeo; break; | 189 | case EntityGeo: t = ValueGeo; break; |
190 | //---------------------------------------------------------------// | 190 | //---------------------------------------------------------------// |
191 | case EntitySource: | 191 | case EntitySource: |
192 | case EntityURL: t = ValueURI; break; | 192 | case EntityURL: t = ValueURI; break; |
193 | //---------------------------------------------------------------// | 193 | //---------------------------------------------------------------// |
194 | case EntityPhoto: | 194 | case EntityPhoto: |
195 | case EntityLogo: t = ValueImage; break; | 195 | case EntityLogo: t = ValueImage; break; |
196 | //---------------------------------------------------------------// | 196 | //---------------------------------------------------------------// |
197 | case EntityBirthday: | 197 | case EntityBirthday: |
198 | case EntityRevision: t = ValueDate; break; | 198 | case EntityRevision: t = ValueDate; break; |
199 | //---------------------------------------------------------------// | 199 | //---------------------------------------------------------------// |
200 | case EntityCategories: | 200 | case EntityCategories: |
201 | case EntityNickname: t = ValueTextList;break; | 201 | case EntityNickname: t = ValueTextList;break; |
202 | //---------------------------------------------------------------// | 202 | //---------------------------------------------------------------// |
203 | case EntityLabel: | 203 | case EntityLabel: |
204 | case EntityExtension: | 204 | case EntityExtension: |
205 | case EntityEmail: | 205 | case EntityEmail: |
206 | case EntityTitle: | 206 | case EntityTitle: |
207 | case EntityRole: | 207 | case EntityRole: |
208 | case EntityFullName: | 208 | case EntityFullName: |
209 | case EntityMailer: | 209 | case EntityMailer: |
210 | case EntityProductID: | 210 | case EntityProductID: |
211 | case EntityName: | 211 | case EntityName: |
212 | case EntitySortString: | 212 | case EntitySortString: |
213 | case EntityVersion: | 213 | case EntityVersion: |
214 | case EntityProfile: | 214 | case EntityProfile: |
215 | case EntityUID: | 215 | case EntityUID: |
216 | case EntityNote: | 216 | case EntityNote: |
217 | default: t = ValueText; break; | 217 | default: t = ValueText; break; |
218 | //---------------------------------------------------------------// | 218 | //---------------------------------------------------------------// |
219 | 219 | ||
220 | } | 220 | } |
221 | 221 | ||
222 | return t; | 222 | return t; |
223 | } | 223 | } |
224 | 224 | ||
225 | QCString | 225 | Q3CString |
226 | VCARD::EntityTypeToParamName(EntityType e) | 226 | VCARD::EntityTypeToParamName(EntityType e) |
227 | { | 227 | { |
228 | if ( e > EntityUnknown ) e = EntityUnknown; | 228 | if ( e > EntityUnknown ) e = EntityUnknown; |
229 | return paramNames[ int( e ) ]; | 229 | return paramNames[ int( e ) ]; |
230 | } | 230 | } |
231 | 231 | ||
232 | EntityType | 232 | EntityType |
233 | VCARD::EntityNameToEntityType(const QCString & s) | 233 | VCARD::EntityNameToEntityType(const Q3CString & s) |
234 | { | 234 | { |
235 | if (s.isEmpty()) return EntityUnknown; | 235 | if (s.isEmpty()) return EntityUnknown; |
236 | 236 | ||
237 | EntityType t(EntityUnknown); | 237 | EntityType t(EntityUnknown); |
238 | 238 | ||
239 | switch (s[0]) { | 239 | switch (s[0]) { |
240 | 240 | ||
241 | case 'A': | 241 | case 'A': |
242 | if (s == "ADR") | 242 | if (s == "ADR") |
243 | t = EntityAddress; | 243 | t = EntityAddress; |
244 | else if (s == "AGENT") | 244 | else if (s == "AGENT") |
245 | t = EntityAgent; | 245 | t = EntityAgent; |
246 | break; | 246 | break; |
247 | 247 | ||
248 | case 'B': | 248 | case 'B': |
249 | if (s == "BDAY") | 249 | if (s == "BDAY") |
250 | t = EntityBirthday; | 250 | t = EntityBirthday; |
251 | break; | 251 | break; |
252 | 252 | ||
253 | case 'C': | 253 | case 'C': |
254 | if (s == "CATEGORIES") | 254 | if (s == "CATEGORIES") |
255 | t = EntityCategories; | 255 | t = EntityCategories; |
256 | else if (s == "CLASS") | 256 | else if (s == "CLASS") |
257 | t = EntityClass; | 257 | t = EntityClass; |
258 | break; | 258 | break; |
259 | 259 | ||
260 | case 'E': | 260 | case 'E': |
261 | if (s == "EMAIL") | 261 | if (s == "EMAIL") |
262 | t = EntityEmail; | 262 | t = EntityEmail; |
263 | break; | 263 | break; |
264 | 264 | ||
265 | case 'F': | 265 | case 'F': |
266 | if (s == "FN") | 266 | if (s == "FN") |
267 | t = EntityFullName; | 267 | t = EntityFullName; |
268 | break; | 268 | break; |
269 | 269 | ||
270 | case 'G': | 270 | case 'G': |
271 | if (s == "GEO") | 271 | if (s == "GEO") |
272 | t = EntityGeo; | 272 | t = EntityGeo; |
273 | break; | 273 | break; |
274 | 274 | ||
275 | case 'K': | 275 | case 'K': |
276 | if (s == "KEY") | 276 | if (s == "KEY") |
277 | t = EntityKey; | 277 | t = EntityKey; |
278 | break; | 278 | break; |
279 | 279 | ||
280 | case 'L': | 280 | case 'L': |
281 | if (s == "LABEL") | 281 | if (s == "LABEL") |
282 | t = EntityLabel; | 282 | t = EntityLabel; |
283 | else if (s == "LOGO") | 283 | else if (s == "LOGO") |
284 | t = EntityLogo; | 284 | t = EntityLogo; |
285 | break; | 285 | break; |
286 | 286 | ||
287 | case 'M': | 287 | case 'M': |
288 | if (s == "MAILER") | 288 | if (s == "MAILER") |
289 | t = EntityMailer; | 289 | t = EntityMailer; |
290 | break; | 290 | break; |
291 | 291 | ||
292 | case 'N': | 292 | case 'N': |
293 | if (s == "N") | 293 | if (s == "N") |
294 | t = EntityN; | 294 | t = EntityN; |
295 | else if (s == "NAME") | 295 | else if (s == "NAME") |
296 | t = EntityName; | 296 | t = EntityName; |
297 | else if (s == "NICKNAME") | 297 | else if (s == "NICKNAME") |
298 | t = EntityNickname; | 298 | t = EntityNickname; |
299 | else if (s == "NOTE") | 299 | else if (s == "NOTE") |
300 | t = EntityNote; | 300 | t = EntityNote; |
301 | break; | 301 | break; |
302 | 302 | ||
303 | case 'O': | 303 | case 'O': |
304 | if (s == "ORG") | 304 | if (s == "ORG") |
305 | t = EntityOrganisation; | 305 | t = EntityOrganisation; |
306 | break; | 306 | break; |
307 | 307 | ||
308 | case 'P': | 308 | case 'P': |
309 | if (s == "PHOTO") | 309 | if (s == "PHOTO") |
310 | t = EntityPhoto; | 310 | t = EntityPhoto; |
311 | else if (s == "PRODID") | 311 | else if (s == "PRODID") |
312 | t = EntityProductID; | 312 | t = EntityProductID; |
313 | else if (s == "PROFILE") | 313 | else if (s == "PROFILE") |
314 | t = EntityProfile; | 314 | t = EntityProfile; |
315 | break; | 315 | break; |
316 | 316 | ||
317 | case 'R': | 317 | case 'R': |
318 | if (s == "REV") | 318 | if (s == "REV") |
319 | t = EntityRevision; | 319 | t = EntityRevision; |
320 | else if (s == "ROLE") | 320 | else if (s == "ROLE") |
321 | t = EntityRole; | 321 | t = EntityRole; |
322 | break; | 322 | break; |
323 | 323 | ||
324 | case 'S': | 324 | case 'S': |
325 | if (s == "SORT-STRING") | 325 | if (s == "SORT-STRING") |
326 | t = EntitySortString; | 326 | t = EntitySortString; |
327 | else if (s == "SOUND") | 327 | else if (s == "SOUND") |
328 | t = EntitySound; | 328 | t = EntitySound; |
329 | else if (s == "SOURCE") | 329 | else if (s == "SOURCE") |
diff --git a/kabc/vcard/FloatValue.cpp b/kabc/vcard/FloatValue.cpp index 15bb664..7065081 100644 --- a/kabc/vcard/FloatValue.cpp +++ b/kabc/vcard/FloatValue.cpp | |||
@@ -1,120 +1,122 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardFloatValue.h> | 24 | #include <VCardFloatValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | FloatValue::FloatValue() | 32 | FloatValue::FloatValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | FloatValue::FloatValue(float f) | 37 | FloatValue::FloatValue(float f) |
36 | : Value(), | 38 | : Value(), |
37 | value_(f) | 39 | value_(f) |
38 | { | 40 | { |
39 | parsed_ = true; | 41 | parsed_ = true; |
40 | } | 42 | } |
41 | 43 | ||
42 | FloatValue::FloatValue(const FloatValue & x) | 44 | FloatValue::FloatValue(const FloatValue & x) |
43 | :Value(x) | 45 | :Value(x) |
44 | { | 46 | { |
45 | value_ = x.value_; | 47 | value_ = x.value_; |
46 | } | 48 | } |
47 | 49 | ||
48 | FloatValue::FloatValue(const QCString & s) | 50 | FloatValue::FloatValue(const Q3CString & s) |
49 | :Value(s) | 51 | :Value(s) |
50 | { | 52 | { |
51 | } | 53 | } |
52 | 54 | ||
53 | FloatValue & | 55 | FloatValue & |
54 | FloatValue::operator = (FloatValue & x) | 56 | FloatValue::operator = (FloatValue & x) |
55 | { | 57 | { |
56 | if (*this == x) return *this; | 58 | if (*this == x) return *this; |
57 | 59 | ||
58 | x.parse(); | 60 | x.parse(); |
59 | value_ = x.value_; | 61 | value_ = x.value_; |
60 | 62 | ||
61 | Value::operator = (x); | 63 | Value::operator = (x); |
62 | return *this; | 64 | return *this; |
63 | } | 65 | } |
64 | 66 | ||
65 | FloatValue & | 67 | FloatValue & |
66 | FloatValue::operator = (const QCString & s) | 68 | FloatValue::operator = (const Q3CString & s) |
67 | { | 69 | { |
68 | Value::operator = (s); | 70 | Value::operator = (s); |
69 | return *this; | 71 | return *this; |
70 | } | 72 | } |
71 | 73 | ||
72 | bool | 74 | bool |
73 | FloatValue::operator == (FloatValue & x) | 75 | FloatValue::operator == (FloatValue & x) |
74 | { | 76 | { |
75 | x.parse(); | 77 | x.parse(); |
76 | return (value_ == x.value_); | 78 | return (value_ == x.value_); |
77 | } | 79 | } |
78 | 80 | ||
79 | FloatValue::~FloatValue() | 81 | FloatValue::~FloatValue() |
80 | { | 82 | { |
81 | } | 83 | } |
82 | 84 | ||
83 | void | 85 | void |
84 | FloatValue::_parse() | 86 | FloatValue::_parse() |
85 | { | 87 | { |
86 | bool negative(false); | 88 | bool negative(false); |
87 | 89 | ||
88 | if (strRep_[0] == '-' || strRep_[1] == '+') { | 90 | if (strRep_[0] == '-' || strRep_[1] == '+') { |
89 | 91 | ||
90 | if (strRep_[0] == '-') | 92 | if (strRep_[0] == '-') |
91 | negative = true; | 93 | negative = true; |
92 | 94 | ||
93 | strRep_.remove(0, 1); | 95 | strRep_.remove(0, 1); |
94 | } | 96 | } |
95 | 97 | ||
96 | value_ = strRep_.toFloat(); | 98 | value_ = strRep_.toFloat(); |
97 | if (negative) | 99 | if (negative) |
98 | value_ = -value_; | 100 | value_ = -value_; |
99 | } | 101 | } |
100 | 102 | ||
101 | void | 103 | void |
102 | FloatValue::_assemble() | 104 | FloatValue::_assemble() |
103 | { | 105 | { |
104 | strRep_ = QCString().setNum(value_); | 106 | strRep_ = Q3CString().setNum(value_); |
105 | } | 107 | } |
106 | 108 | ||
107 | float | 109 | float |
108 | FloatValue::value() | 110 | FloatValue::value() |
109 | { | 111 | { |
110 | parse(); | 112 | parse(); |
111 | return value_; | 113 | return value_; |
112 | } | 114 | } |
113 | 115 | ||
114 | void | 116 | void |
115 | FloatValue::setValue(float f) | 117 | FloatValue::setValue(float f) |
116 | { | 118 | { |
117 | parsed_ = true; | 119 | parsed_ = true; |
118 | value_ = f; | 120 | value_ = f; |
119 | } | 121 | } |
120 | 122 | ||
diff --git a/kabc/vcard/GeoValue.cpp b/kabc/vcard/GeoValue.cpp index e02b402..ba57a6b 100644 --- a/kabc/vcard/GeoValue.cpp +++ b/kabc/vcard/GeoValue.cpp | |||
@@ -1,100 +1,102 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of libvcard. | 2 | This file is part of libvcard. |
3 | Copyright (c) 2002 Tobias Koenig <tokoe@kde.org> | 3 | Copyright (c) 2002 Tobias Koenig <tokoe@kde.org> |
4 | 4 | ||
5 | This library is free software; you can redistribute it and/or | 5 | This library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Library General Public | 6 | modify it under the terms of the GNU Library General Public |
7 | License as published by the Free Software Foundation; either | 7 | License as published by the Free Software Foundation; either |
8 | version 2 of the License, or (at your option) any later version. | 8 | version 2 of the License, or (at your option) any later version. |
9 | 9 | ||
10 | This library is distributed in the hope that it will be useful, | 10 | This library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Library General Public License for more details. | 13 | Library General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Library General Public License | 15 | You should have received a copy of the GNU Library General Public License |
16 | along with this library; see the file COPYING.LIB. If not, write to | 16 | along with this library; see the file COPYING.LIB. If not, write to |
17 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | 17 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
18 | Boston, MA 02111-1307, USA. | 18 | Boston, MA 02111-1307, USA. |
19 | */ | 19 | */ |
20 | 20 | ||
21 | #include <VCardGeoValue.h> | 21 | #include <VCardGeoValue.h> |
22 | 22 | ||
23 | #include <VCardValue.h> | 23 | #include <VCardValue.h> |
24 | 24 | ||
25 | #include <kdebug.h> | 25 | #include <kdebug.h> |
26 | //Added by qt3to4: | ||
27 | #include <Q3CString> | ||
26 | 28 | ||
27 | using namespace VCARD; | 29 | using namespace VCARD; |
28 | 30 | ||
29 | GeoValue::GeoValue() | 31 | GeoValue::GeoValue() |
30 | :Value() | 32 | :Value() |
31 | { | 33 | { |
32 | } | 34 | } |
33 | 35 | ||
34 | GeoValue::GeoValue(const GeoValue & x) | 36 | GeoValue::GeoValue(const GeoValue & x) |
35 | :Value(x), latitude_(x.latitude_), longitude_(x.longitude_) | 37 | :Value(x), latitude_(x.latitude_), longitude_(x.longitude_) |
36 | { | 38 | { |
37 | } | 39 | } |
38 | 40 | ||
39 | GeoValue::GeoValue(const QCString & s) | 41 | GeoValue::GeoValue(const Q3CString & s) |
40 | :Value(s) | 42 | :Value(s) |
41 | { | 43 | { |
42 | } | 44 | } |
43 | 45 | ||
44 | GeoValue & | 46 | GeoValue & |
45 | GeoValue::operator = (GeoValue & x) | 47 | GeoValue::operator = (GeoValue & x) |
46 | { | 48 | { |
47 | if (*this == x) return *this; | 49 | if (*this == x) return *this; |
48 | 50 | ||
49 | latitude_ = x.latitude_; | 51 | latitude_ = x.latitude_; |
50 | longitude_ = x.longitude_; | 52 | longitude_ = x.longitude_; |
51 | 53 | ||
52 | Value::operator = (x); | 54 | Value::operator = (x); |
53 | return *this; | 55 | return *this; |
54 | } | 56 | } |
55 | 57 | ||
56 | GeoValue & | 58 | GeoValue & |
57 | GeoValue::operator = (const QCString & s) | 59 | GeoValue::operator = (const Q3CString & s) |
58 | { | 60 | { |
59 | Value::operator = (s); | 61 | Value::operator = (s); |
60 | return *this; | 62 | return *this; |
61 | } | 63 | } |
62 | 64 | ||
63 | bool | 65 | bool |
64 | GeoValue::operator == (GeoValue & x) | 66 | GeoValue::operator == (GeoValue & x) |
65 | { | 67 | { |
66 | x.parse(); | 68 | x.parse(); |
67 | 69 | ||
68 | if ( latitude_ != x.latitude_ ) return false; | 70 | if ( latitude_ != x.latitude_ ) return false; |
69 | if ( longitude_ != x.longitude_ ) return false; | 71 | if ( longitude_ != x.longitude_ ) return false; |
70 | 72 | ||
71 | return true; | 73 | return true; |
72 | } | 74 | } |
73 | 75 | ||
74 | GeoValue::~GeoValue() | 76 | GeoValue::~GeoValue() |
75 | { | 77 | { |
76 | } | 78 | } |
77 | 79 | ||
78 | GeoValue * | 80 | GeoValue * |
79 | GeoValue::clone() | 81 | GeoValue::clone() |
80 | { | 82 | { |
81 | return new GeoValue( *this ); | 83 | return new GeoValue( *this ); |
82 | } | 84 | } |
83 | 85 | ||
84 | void | 86 | void |
85 | GeoValue::_parse() | 87 | GeoValue::_parse() |
86 | { | 88 | { |
87 | int semiColon = strRep_.find( ";" ); | 89 | int semiColon = strRep_.find( ";" ); |
88 | 90 | ||
89 | if ( semiColon == -1 ) // invalid | 91 | if ( semiColon == -1 ) // invalid |
90 | return; | 92 | return; |
91 | 93 | ||
92 | latitude_ = strRep_.left( semiColon ).toFloat(); | 94 | latitude_ = strRep_.left( semiColon ).toFloat(); |
93 | longitude_ = strRep_.mid( semiColon + 1, strRep_.length() - semiColon ).toFloat(); | 95 | longitude_ = strRep_.mid( semiColon + 1, strRep_.length() - semiColon ).toFloat(); |
94 | } | 96 | } |
95 | 97 | ||
96 | void | 98 | void |
97 | GeoValue::_assemble() | 99 | GeoValue::_assemble() |
98 | { | 100 | { |
99 | strRep_.sprintf( "%.6f;%.6f", latitude_, longitude_ ); | 101 | strRep_.sprintf( "%.6f;%.6f", latitude_, longitude_ ); |
100 | } | 102 | } |
diff --git a/kabc/vcard/ImageParam.cpp b/kabc/vcard/ImageParam.cpp index c9cf6fd..6da317d 100644 --- a/kabc/vcard/ImageParam.cpp +++ b/kabc/vcard/ImageParam.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardImageParam.h> | 24 | #include <VCardImageParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | ImageParam::ImageParam() | 32 | ImageParam::ImageParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | ImageParam::ImageParam(const ImageParam & x) | 37 | ImageParam::ImageParam(const ImageParam & x) |
36 | :Param(x) | 38 | :Param(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | ImageParam::ImageParam(const QCString & s) | 42 | ImageParam::ImageParam(const Q3CString & s) |
41 | :Param(s) | 43 | :Param(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | ImageParam & | 47 | ImageParam & |
46 | ImageParam::operator = (ImageParam & x) | 48 | ImageParam::operator = (ImageParam & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Param::operator = (x); | 52 | Param::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | ImageParam & | 56 | ImageParam & |
55 | ImageParam::operator = (const QCString & s) | 57 | ImageParam::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Param::operator = (s); | 59 | Param::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | ImageParam::operator == (ImageParam & x) | 64 | ImageParam::operator == (ImageParam & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | ImageParam::~ImageParam() | 70 | ImageParam::~ImageParam() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | ImageParam::_parse() | 75 | ImageParam::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | ImageParam::_assemble() | 80 | ImageParam::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/ImageValue.cpp b/kabc/vcard/ImageValue.cpp index 4630fac..678a81c 100644 --- a/kabc/vcard/ImageValue.cpp +++ b/kabc/vcard/ImageValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardImageValue.h> | 24 | #include <VCardImageValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | ImageValue::ImageValue() | 32 | ImageValue::ImageValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | ImageValue::ImageValue(const ImageValue & x) | 37 | ImageValue::ImageValue(const ImageValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | ImageValue::ImageValue(const QCString & s) | 42 | ImageValue::ImageValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | ImageValue & | 47 | ImageValue & |
46 | ImageValue::operator = (ImageValue & x) | 48 | ImageValue::operator = (ImageValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | ImageValue & | 56 | ImageValue & |
55 | ImageValue::operator = (const QCString & s) | 57 | ImageValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | ImageValue::operator == (ImageValue & x) | 64 | ImageValue::operator == (ImageValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | ImageValue::~ImageValue() | 70 | ImageValue::~ImageValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | ImageValue::_parse() | 75 | ImageValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | ImageValue::_assemble() | 80 | ImageValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/ImgValue.cpp b/kabc/vcard/ImgValue.cpp index 7b961f8..1b289df 100644 --- a/kabc/vcard/ImgValue.cpp +++ b/kabc/vcard/ImgValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardImgValue.h> | 24 | #include <VCardImgValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | ImgValue::ImgValue() | 32 | ImgValue::ImgValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | ImgValue::ImgValue(const ImgValue & x) | 37 | ImgValue::ImgValue(const ImgValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | ImgValue::ImgValue(const QCString & s) | 42 | ImgValue::ImgValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | ImgValue & | 47 | ImgValue & |
46 | ImgValue::operator = (ImgValue & x) | 48 | ImgValue::operator = (ImgValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | ImgValue & | 56 | ImgValue & |
55 | ImgValue::operator = (const QCString & s) | 57 | ImgValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | ImgValue::operator == (ImgValue & x) | 64 | ImgValue::operator == (ImgValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | ImgValue::~ImgValue() | 70 | ImgValue::~ImgValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | ImgValue::_parse() | 75 | ImgValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | ImgValue::_assemble() | 80 | ImgValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/LangValue.cpp b/kabc/vcard/LangValue.cpp index edf1804..52a0204 100644 --- a/kabc/vcard/LangValue.cpp +++ b/kabc/vcard/LangValue.cpp | |||
@@ -1,127 +1,131 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardRToken.h> | 24 | #include <VCardRToken.h> |
25 | 25 | ||
26 | #include <VCardLangValue.h> | 26 | #include <VCardLangValue.h> |
27 | 27 | ||
28 | #include <VCardValue.h> | 28 | #include <VCardValue.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
31 | #include <Q3StrList> | ||
29 | 32 | ||
30 | using namespace VCARD; | 33 | using namespace VCARD; |
31 | 34 | ||
32 | LangValue::LangValue() | 35 | LangValue::LangValue() |
33 | :Value() | 36 | :Value() |
34 | { | 37 | { |
35 | } | 38 | } |
36 | 39 | ||
37 | LangValue::LangValue(const LangValue & x) | 40 | LangValue::LangValue(const LangValue & x) |
38 | :Value(x) | 41 | :Value(x) |
39 | { | 42 | { |
40 | } | 43 | } |
41 | 44 | ||
42 | LangValue::LangValue(const QCString & s) | 45 | LangValue::LangValue(const Q3CString & s) |
43 | :Value(s) | 46 | :Value(s) |
44 | { | 47 | { |
45 | } | 48 | } |
46 | 49 | ||
47 | LangValue & | 50 | LangValue & |
48 | LangValue::operator = (LangValue & x) | 51 | LangValue::operator = (LangValue & x) |
49 | { | 52 | { |
50 | if (*this == x) return *this; | 53 | if (*this == x) return *this; |
51 | 54 | ||
52 | Value::operator = (x); | 55 | Value::operator = (x); |
53 | return *this; | 56 | return *this; |
54 | } | 57 | } |
55 | 58 | ||
56 | LangValue & | 59 | LangValue & |
57 | LangValue::operator = (const QCString & s) | 60 | LangValue::operator = (const Q3CString & s) |
58 | { | 61 | { |
59 | Value::operator = (s); | 62 | Value::operator = (s); |
60 | return *this; | 63 | return *this; |
61 | } | 64 | } |
62 | 65 | ||
63 | bool | 66 | bool |
64 | LangValue::operator == (LangValue & x) | 67 | LangValue::operator == (LangValue & x) |
65 | { | 68 | { |
66 | x.parse(); | 69 | x.parse(); |
67 | return false; | 70 | return false; |
68 | } | 71 | } |
69 | 72 | ||
70 | LangValue::~LangValue() | 73 | LangValue::~LangValue() |
71 | { | 74 | { |
72 | } | 75 | } |
73 | 76 | ||
74 | void | 77 | void |
75 | LangValue::_parse() | 78 | LangValue::_parse() |
76 | { | 79 | { |
77 | QStrList l; | 80 | Q3StrList l; |
78 | RTokenise(strRep_, "-", l); | 81 | RTokenise(strRep_, "-", l); |
79 | 82 | ||
80 | if (l.count() == 0) return; | 83 | if (l.count() == 0) return; |
81 | 84 | ||
82 | primary_ = l.at(0); | 85 | primary_ = l.at(0); |
83 | 86 | ||
84 | l.remove(0u); | 87 | l.remove(0u); |
85 | 88 | ||
86 | subtags_ = l; | 89 | subtags_ = l; |
87 | } | 90 | } |
88 | 91 | ||
89 | void | 92 | void |
90 | LangValue::_assemble() | 93 | LangValue::_assemble() |
91 | { | 94 | { |
92 | strRep_ = primary_; | 95 | strRep_ = primary_; |
93 | 96 | ||
94 | QStrListIterator it(subtags_); | 97 | Q3StrListIterator it(subtags_); |
95 | 98 | ||
96 | for (; it.current(); ++it) | 99 | for (; it.current(); ++it) { |
97 | strRep_ += QCString('-') + it.current(); | 100 | strRep_ += Q3CString('-'); strRep_ += it.current(); |
101 | } | ||
98 | } | 102 | } |
99 | 103 | ||
100 | QCString | 104 | Q3CString |
101 | LangValue::primary() | 105 | LangValue::primary() |
102 | { | 106 | { |
103 | parse(); | 107 | parse(); |
104 | return primary_; | 108 | return primary_; |
105 | } | 109 | } |
106 | 110 | ||
107 | QStrList | 111 | Q3StrList |
108 | LangValue::subtags() | 112 | LangValue::subtags() |
109 | { | 113 | { |
110 | parse(); | 114 | parse(); |
111 | return subtags_; | 115 | return subtags_; |
112 | } | 116 | } |
113 | 117 | ||
114 | void | 118 | void |
115 | LangValue::setPrimary(const QCString & s) | 119 | LangValue::setPrimary(const Q3CString & s) |
116 | { | 120 | { |
117 | parse(); | 121 | parse(); |
118 | primary_ = s; | 122 | primary_ = s; |
119 | } | 123 | } |
120 | 124 | ||
121 | void | 125 | void |
122 | LangValue::setSubTags(const QStrList & l) | 126 | LangValue::setSubTags(const Q3StrList & l) |
123 | { | 127 | { |
124 | parse(); | 128 | parse(); |
125 | subtags_ = l; | 129 | subtags_ = l; |
126 | } | 130 | } |
127 | 131 | ||
diff --git a/kabc/vcard/NValue.cpp b/kabc/vcard/NValue.cpp index cdec621..6c0f365 100644 --- a/kabc/vcard/NValue.cpp +++ b/kabc/vcard/NValue.cpp | |||
@@ -1,128 +1,130 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qstrlist.h> | 24 | #include <q3strlist.h> |
25 | //Added by qt3to4: | ||
26 | #include <Q3CString> | ||
25 | 27 | ||
26 | #include <VCardRToken.h> | 28 | #include <VCardRToken.h> |
27 | #include <VCardNValue.h> | 29 | #include <VCardNValue.h> |
28 | #include <VCardValue.h> | 30 | #include <VCardValue.h> |
29 | #include <VCardDefines.h> | 31 | #include <VCardDefines.h> |
30 | 32 | ||
31 | using namespace VCARD; | 33 | using namespace VCARD; |
32 | 34 | ||
33 | NValue::NValue() | 35 | NValue::NValue() |
34 | :Value() | 36 | :Value() |
35 | { | 37 | { |
36 | vDebug("ctor"); | 38 | vDebug("ctor"); |
37 | } | 39 | } |
38 | 40 | ||
39 | NValue::NValue(const NValue & x) | 41 | NValue::NValue(const NValue & x) |
40 | :Value(x), | 42 | :Value(x), |
41 | family_(x.family_), | 43 | family_(x.family_), |
42 | given_(x.given_), | 44 | given_(x.given_), |
43 | middle_(x.middle_), | 45 | middle_(x.middle_), |
44 | prefix_(x.prefix_), | 46 | prefix_(x.prefix_), |
45 | suffix_(x.suffix_) | 47 | suffix_(x.suffix_) |
46 | { | 48 | { |
47 | } | 49 | } |
48 | 50 | ||
49 | NValue::NValue(const QCString & s) | 51 | NValue::NValue(const Q3CString & s) |
50 | :Value(s) | 52 | :Value(s) |
51 | { | 53 | { |
52 | vDebug("ctor"); | 54 | vDebug("ctor"); |
53 | } | 55 | } |
54 | 56 | ||
55 | NValue & | 57 | NValue & |
56 | NValue::operator = (NValue & x) | 58 | NValue::operator = (NValue & x) |
57 | { | 59 | { |
58 | if (*this == x) return *this; | 60 | if (*this == x) return *this; |
59 | 61 | ||
60 | family_= x.family_; | 62 | family_= x.family_; |
61 | given_= x.given_; | 63 | given_= x.given_; |
62 | middle_= x.middle_; | 64 | middle_= x.middle_; |
63 | prefix_= x.prefix_; | 65 | prefix_= x.prefix_; |
64 | suffix_= x.suffix_; | 66 | suffix_= x.suffix_; |
65 | 67 | ||
66 | Value::operator = (x); | 68 | Value::operator = (x); |
67 | return *this; | 69 | return *this; |
68 | } | 70 | } |
69 | 71 | ||
70 | NValue & | 72 | NValue & |
71 | NValue::operator = (const QCString & s) | 73 | NValue::operator = (const Q3CString & s) |
72 | { | 74 | { |
73 | Value::operator = (s); | 75 | Value::operator = (s); |
74 | return *this; | 76 | return *this; |
75 | } | 77 | } |
76 | 78 | ||
77 | bool | 79 | bool |
78 | NValue::operator == (NValue & x) | 80 | NValue::operator == (NValue & x) |
79 | { | 81 | { |
80 | x.parse(); | 82 | x.parse(); |
81 | 83 | ||
82 | return ( | 84 | return ( |
83 | family_ == x.family_&& | 85 | family_ == x.family_&& |
84 | given_ == x.given_&& | 86 | given_ == x.given_&& |
85 | middle_ == x.middle_&& | 87 | middle_ == x.middle_&& |
86 | prefix_ == x.prefix_&& | 88 | prefix_ == x.prefix_&& |
87 | suffix_ == x.suffix_); | 89 | suffix_ == x.suffix_); |
88 | } | 90 | } |
89 | 91 | ||
90 | NValue::~NValue() | 92 | NValue::~NValue() |
91 | { | 93 | { |
92 | } | 94 | } |
93 | 95 | ||
94 | NValue * | 96 | NValue * |
95 | NValue::clone() | 97 | NValue::clone() |
96 | { | 98 | { |
97 | return new NValue( *this ); | 99 | return new NValue( *this ); |
98 | } | 100 | } |
99 | 101 | ||
100 | void | 102 | void |
101 | NValue::_parse() | 103 | NValue::_parse() |
102 | { | 104 | { |
103 | QStrList l; | 105 | Q3StrList l; |
104 | RTokenise(strRep_, ";", l); | 106 | RTokenise(strRep_, ";", l); |
105 | 107 | ||
106 | for (unsigned int i = 0; i < l.count(); i++) { | 108 | for (unsigned int i = 0; i < l.count(); i++) { |
107 | 109 | ||
108 | switch (i) { | 110 | switch (i) { |
109 | case 0: family_ = l.at(0);break; | 111 | case 0: family_ = l.at(0);break; |
110 | case 1: given_ = l.at(1);break; | 112 | case 1: given_ = l.at(1);break; |
111 | case 2: middle_ = l.at(2);break; | 113 | case 2: middle_ = l.at(2);break; |
112 | case 3: prefix_ = l.at(3);break; | 114 | case 3: prefix_ = l.at(3);break; |
113 | case 4: suffix_ = l.at(4);break; | 115 | case 4: suffix_ = l.at(4);break; |
114 | default: break; | 116 | default: break; |
115 | } | 117 | } |
116 | } | 118 | } |
117 | } | 119 | } |
118 | 120 | ||
119 | void | 121 | void |
120 | NValue::_assemble() | 122 | NValue::_assemble() |
121 | { | 123 | { |
122 | strRep_ = family_; | 124 | strRep_ = family_; |
123 | strRep_ += ";" +given_; | 125 | strRep_ += ";" +given_; |
124 | strRep_ += ";" +middle_; | 126 | strRep_ += ";" +middle_; |
125 | strRep_ += ";" +prefix_; | 127 | strRep_ += ";" +prefix_; |
126 | strRep_ += ";" +suffix_; | 128 | strRep_ += ";" +suffix_; |
127 | } | 129 | } |
128 | 130 | ||
diff --git a/kabc/vcard/OrgValue.cpp b/kabc/vcard/OrgValue.cpp index c3134c8..a6a32dd 100644 --- a/kabc/vcard/OrgValue.cpp +++ b/kabc/vcard/OrgValue.cpp | |||
@@ -1,107 +1,109 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardRToken.h> | 24 | #include <VCardRToken.h> |
25 | 25 | ||
26 | #include <VCardOrgValue.h> | 26 | #include <VCardOrgValue.h> |
27 | 27 | ||
28 | #include <VCardValue.h> | 28 | #include <VCardValue.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
29 | 31 | ||
30 | using namespace VCARD; | 32 | using namespace VCARD; |
31 | 33 | ||
32 | OrgValue::OrgValue() | 34 | OrgValue::OrgValue() |
33 | :Value() | 35 | :Value() |
34 | { | 36 | { |
35 | } | 37 | } |
36 | 38 | ||
37 | OrgValue::OrgValue(const OrgValue & x) | 39 | OrgValue::OrgValue(const OrgValue & x) |
38 | :Value(x) | 40 | :Value(x) |
39 | { | 41 | { |
40 | } | 42 | } |
41 | 43 | ||
42 | OrgValue::OrgValue(const QCString & s) | 44 | OrgValue::OrgValue(const Q3CString & s) |
43 | :Value(s) | 45 | :Value(s) |
44 | { | 46 | { |
45 | } | 47 | } |
46 | 48 | ||
47 | OrgValue & | 49 | OrgValue & |
48 | OrgValue::operator = (OrgValue & x) | 50 | OrgValue::operator = (OrgValue & x) |
49 | { | 51 | { |
50 | if (*this == x) return *this; | 52 | if (*this == x) return *this; |
51 | 53 | ||
52 | Value::operator = (x); | 54 | Value::operator = (x); |
53 | return *this; | 55 | return *this; |
54 | } | 56 | } |
55 | 57 | ||
56 | OrgValue & | 58 | OrgValue & |
57 | OrgValue::operator = (const QCString & s) | 59 | OrgValue::operator = (const Q3CString & s) |
58 | { | 60 | { |
59 | Value::operator = (s); | 61 | Value::operator = (s); |
60 | return *this; | 62 | return *this; |
61 | } | 63 | } |
62 | 64 | ||
63 | bool | 65 | bool |
64 | OrgValue::operator == (OrgValue & x) | 66 | OrgValue::operator == (OrgValue & x) |
65 | { | 67 | { |
66 | x.parse(); | 68 | x.parse(); |
67 | return false; | 69 | return false; |
68 | } | 70 | } |
69 | 71 | ||
70 | OrgValue::~OrgValue() | 72 | OrgValue::~OrgValue() |
71 | { | 73 | { |
72 | } | 74 | } |
73 | 75 | ||
74 | void | 76 | void |
75 | OrgValue::_parse() | 77 | OrgValue::_parse() |
76 | { | 78 | { |
77 | RTokenise(strRep_, ";", valueList_); | 79 | RTokenise(strRep_, ";", valueList_); |
78 | } | 80 | } |
79 | 81 | ||
80 | void | 82 | void |
81 | OrgValue::_assemble() | 83 | OrgValue::_assemble() |
82 | { | 84 | { |
83 | bool first(true); | 85 | bool first(true); |
84 | 86 | ||
85 | QStrListIterator it(valueList_); | 87 | Q3StrListIterator it(valueList_); |
86 | 88 | ||
87 | for (; it.current(); ++it) { | 89 | for (; it.current(); ++it) { |
88 | if (!first) strRep_ += ';'; | 90 | if (!first) strRep_ += ';'; |
89 | strRep_ += it.current(); | 91 | strRep_ += it.current(); |
90 | first = false; | 92 | first = false; |
91 | } | 93 | } |
92 | } | 94 | } |
93 | 95 | ||
94 | unsigned int | 96 | unsigned int |
95 | OrgValue::numValues() | 97 | OrgValue::numValues() |
96 | { | 98 | { |
97 | parse(); | 99 | parse(); |
98 | return valueList_.count(); | 100 | return valueList_.count(); |
99 | } | 101 | } |
100 | 102 | ||
101 | QCString | 103 | Q3CString |
102 | OrgValue::value(unsigned int i) | 104 | OrgValue::value(unsigned int i) |
103 | { | 105 | { |
104 | parse(); | 106 | parse(); |
105 | return valueList_.at(i); | 107 | return valueList_.at(i); |
106 | } | 108 | } |
107 | 109 | ||
diff --git a/kabc/vcard/Param.cpp b/kabc/vcard/Param.cpp index c513613..bd6b299 100644 --- a/kabc/vcard/Param.cpp +++ b/kabc/vcard/Param.cpp | |||
@@ -1,129 +1,131 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardParam.h> | 24 | #include <VCardParam.h> |
25 | 25 | ||
26 | #include <VCardEntity.h> | 26 | #include <VCardEntity.h> |
27 | 27 | ||
28 | #include <VCardRToken.h> | 28 | #include <VCardRToken.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
29 | 31 | ||
30 | using namespace VCARD; | 32 | using namespace VCARD; |
31 | 33 | ||
32 | Param::Param() | 34 | Param::Param() |
33 | :Entity(), | 35 | :Entity(), |
34 | name_(""), | 36 | name_(""), |
35 | value_("") | 37 | value_("") |
36 | { | 38 | { |
37 | } | 39 | } |
38 | 40 | ||
39 | Param::Param(const Param & x) | 41 | Param::Param(const Param & x) |
40 | :Entity(x), | 42 | :Entity(x), |
41 | name_(x.name_), | 43 | name_(x.name_), |
42 | value_(x.value_) | 44 | value_(x.value_) |
43 | { | 45 | { |
44 | } | 46 | } |
45 | 47 | ||
46 | Param::Param(const QCString & s) | 48 | Param::Param(const Q3CString & s) |
47 | :Entity(s), | 49 | :Entity(s), |
48 | name_(""), | 50 | name_(""), |
49 | value_("") | 51 | value_("") |
50 | { | 52 | { |
51 | } | 53 | } |
52 | 54 | ||
53 | Param & | 55 | Param & |
54 | Param::operator = (Param & x) | 56 | Param::operator = (Param & x) |
55 | { | 57 | { |
56 | if (*this == x) return *this; | 58 | if (*this == x) return *this; |
57 | 59 | ||
58 | Entity::operator = (x); | 60 | Entity::operator = (x); |
59 | name_ = x.name_; | 61 | name_ = x.name_; |
60 | value_ = x.value_; | 62 | value_ = x.value_; |
61 | 63 | ||
62 | return *this; | 64 | return *this; |
63 | } | 65 | } |
64 | 66 | ||
65 | Param & | 67 | Param & |
66 | Param::operator = (const QCString & s) | 68 | Param::operator = (const Q3CString & s) |
67 | { | 69 | { |
68 | Entity::operator = (s); | 70 | Entity::operator = (s); |
69 | return *this; | 71 | return *this; |
70 | } | 72 | } |
71 | 73 | ||
72 | bool | 74 | bool |
73 | Param::operator == (Param & x) | 75 | Param::operator == (Param & x) |
74 | { | 76 | { |
75 | x.parse(); | 77 | x.parse(); |
76 | return false; | 78 | return false; |
77 | } | 79 | } |
78 | 80 | ||
79 | Param::~Param() | 81 | Param::~Param() |
80 | { | 82 | { |
81 | } | 83 | } |
82 | 84 | ||
83 | void | 85 | void |
84 | Param::_parse() | 86 | Param::_parse() |
85 | { | 87 | { |
86 | } | 88 | } |
87 | 89 | ||
88 | void | 90 | void |
89 | Param::_assemble() | 91 | Param::_assemble() |
90 | { | 92 | { |
91 | strRep_ = name_ + "=" + value_; | 93 | strRep_ = name_ + "=" + value_; |
92 | } | 94 | } |
93 | 95 | ||
94 | Param::Param(const QCString &name, const QCString &value) | 96 | Param::Param(const Q3CString &name, const Q3CString &value) |
95 | :Entity(), | 97 | :Entity(), |
96 | name_(name), | 98 | name_(name), |
97 | value_(value) | 99 | value_(value) |
98 | { | 100 | { |
99 | parsed_ = true; | 101 | parsed_ = true; |
100 | assembled_ = false; | 102 | assembled_ = false; |
101 | } | 103 | } |
102 | 104 | ||
103 | void | 105 | void |
104 | Param::setName(const QCString & name) | 106 | Param::setName(const Q3CString & name) |
105 | { | 107 | { |
106 | name_ = name; | 108 | name_ = name; |
107 | 109 | ||
108 | assembled_ = false; | 110 | assembled_ = false; |
109 | } | 111 | } |
110 | 112 | ||
111 | void | 113 | void |
112 | Param::setValue(const QCString & value) | 114 | Param::setValue(const Q3CString & value) |
113 | { | 115 | { |
114 | value_ = value; | 116 | value_ = value; |
115 | 117 | ||
116 | assembled_ = false; | 118 | assembled_ = false; |
117 | } | 119 | } |
118 | 120 | ||
119 | QCString | 121 | Q3CString |
120 | Param::name() | 122 | Param::name() |
121 | { | 123 | { |
122 | return name_; | 124 | return name_; |
123 | } | 125 | } |
124 | 126 | ||
125 | QCString | 127 | Q3CString |
126 | Param::value() | 128 | Param::value() |
127 | { | 129 | { |
128 | return value_; | 130 | return value_; |
129 | } | 131 | } |
diff --git a/kabc/vcard/PhoneNumberValue.cpp b/kabc/vcard/PhoneNumberValue.cpp index 17b1400..57aa336 100644 --- a/kabc/vcard/PhoneNumberValue.cpp +++ b/kabc/vcard/PhoneNumberValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardPhoneNumberValue.h> | 24 | #include <VCardPhoneNumberValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | PhoneNumberValue::PhoneNumberValue() | 32 | PhoneNumberValue::PhoneNumberValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | PhoneNumberValue::PhoneNumberValue(const PhoneNumberValue & x) | 37 | PhoneNumberValue::PhoneNumberValue(const PhoneNumberValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | PhoneNumberValue::PhoneNumberValue(const QCString & s) | 42 | PhoneNumberValue::PhoneNumberValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | PhoneNumberValue & | 47 | PhoneNumberValue & |
46 | PhoneNumberValue::operator = (PhoneNumberValue & x) | 48 | PhoneNumberValue::operator = (PhoneNumberValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | PhoneNumberValue & | 56 | PhoneNumberValue & |
55 | PhoneNumberValue::operator = (const QCString & s) | 57 | PhoneNumberValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | PhoneNumberValue::operator == (PhoneNumberValue & x) | 64 | PhoneNumberValue::operator == (PhoneNumberValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | PhoneNumberValue::~PhoneNumberValue() | 70 | PhoneNumberValue::~PhoneNumberValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | PhoneNumberValue::_parse() | 75 | PhoneNumberValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | PhoneNumberValue::_assemble() | 80 | PhoneNumberValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/RToken.cpp b/kabc/vcard/RToken.cpp index 2a85820..8fc0558 100644 --- a/kabc/vcard/RToken.cpp +++ b/kabc/vcard/RToken.cpp | |||
@@ -1,88 +1,88 @@ | |||
1 | /* | 1 | /* |
2 | 2 | ||
3 | libvcard - vCard parsing library for vCard version 3.0 | 3 | libvcard - vCard parsing library for vCard version 3.0 |
4 | 4 | ||
5 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 5 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
6 | 6 | ||
7 | Permission is hereby granted, free of charge, to any person obtaining a copy | 7 | Permission is hereby granted, free of charge, to any person obtaining a copy |
8 | of this software and associated documentation files (the "Software"), to | 8 | of this software and associated documentation files (the "Software"), to |
9 | deal in the Software without restriction, including without limitation the | 9 | deal in the Software without restriction, including without limitation the |
10 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 10 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
11 | sell copies of the Software, and to permit persons to whom the Software is | 11 | sell copies of the Software, and to permit persons to whom the Software is |
12 | furnished to do so, subject to the following conditions: | 12 | furnished to do so, subject to the following conditions: |
13 | 13 | ||
14 | The above copyright notice and this permission notice shall be included in | 14 | The above copyright notice and this permission notice shall be included in |
15 | all copies or substantial portions of the Software. | 15 | all copies or substantial portions of the Software. |
16 | 16 | ||
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
20 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 20 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
21 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 21 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
23 | */ | 23 | */ |
24 | 24 | ||
25 | #include <string.h> | 25 | #include <string.h> |
26 | #include <stddef.h> | 26 | #include <stddef.h> |
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qstrlist.h> | 28 | #include <q3strlist.h> |
29 | 29 | ||
30 | namespace VCARD | 30 | namespace VCARD |
31 | { | 31 | { |
32 | 32 | ||
33 | Q_UINT32 | 33 | Q_UINT32 |
34 | RTokenise(const char * str, const char * delim, QStrList & l) | 34 | RTokenise(const char * str, const char * delim, Q3StrList & l) |
35 | { | 35 | { |
36 | // FIXME no stderr ! | 36 | // FIXME no stderr ! |
37 | l.clear(); | 37 | l.clear(); |
38 | 38 | ||
39 | if (!delim || !str || strlen(delim) == 0 || strlen(str) == 0) return 0; | 39 | if (!delim || !str || strlen(delim) == 0 || strlen(str) == 0) return 0; |
40 | 40 | ||
41 | char * len = (char *)(str + strlen(str));// End of string. | 41 | char * len = (char *)(str + strlen(str));// End of string. |
42 | 42 | ||
43 | register char * rstart = new char[strlen(str) + 1]; | 43 | register char * rstart = new char[strlen(str) + 1]; |
44 | register char * r = rstart; | 44 | register char * r = rstart; |
45 | 45 | ||
46 | 46 | ||
47 | register const char * i = str;// Cursor. | 47 | register const char * i = str;// Cursor. |
48 | 48 | ||
49 | while (i <= len) { | 49 | while (i <= len) { |
50 | 50 | ||
51 | if (*i == '\\') { // Escaped chars go straight through. | 51 | if (*i == '\\') { // Escaped chars go straight through. |
52 | *r++ = *i++; | 52 | *r++ = *i++; |
53 | if (i <= len) | 53 | if (i <= len) |
54 | *r++ = *i++; | 54 | *r++ = *i++; |
55 | continue; | 55 | continue; |
56 | } | 56 | } |
57 | 57 | ||
58 | if (strchr(delim, *i) != 0) { | 58 | if (strchr(delim, *i) != 0) { |
59 | // We hit a delimiter. If we have some text, make a new token. | 59 | // We hit a delimiter. If we have some text, make a new token. |
60 | // This has the effect that multiple delimiters are collapsed. | 60 | // This has the effect that multiple delimiters are collapsed. |
61 | // cs: We mustn't collapse multiple delimiters, otherwise we | 61 | // cs: We mustn't collapse multiple delimiters, otherwise we |
62 | // lose empty fields. | 62 | // lose empty fields. |
63 | *r = '\0'; | 63 | *r = '\0'; |
64 | // if (r != rstart) { | 64 | // if (r != rstart) { |
65 | l.append(rstart); | 65 | l.append(rstart); |
66 | // } | 66 | // } |
67 | r = rstart; | 67 | r = rstart; |
68 | ++i; | 68 | ++i; |
69 | continue; | 69 | continue; |
70 | } | 70 | } |
71 | 71 | ||
72 | *r++ = *i++; | 72 | *r++ = *i++; |
73 | } | 73 | } |
74 | 74 | ||
75 | // Catch last token | 75 | // Catch last token |
76 | //if (r != rstart) { | 76 | //if (r != rstart) { |
77 | *r = '\0'; | 77 | *r = '\0'; |
78 | l.append(rstart); | 78 | l.append(rstart); |
79 | //} | 79 | //} |
80 | 80 | ||
81 | r = 0; | 81 | r = 0; |
82 | 82 | ||
83 | delete [] rstart; | 83 | delete [] rstart; |
84 | 84 | ||
85 | return l.count(); | 85 | return l.count(); |
86 | } | 86 | } |
87 | 87 | ||
88 | } | 88 | } |
diff --git a/kabc/vcard/SoundValue.cpp b/kabc/vcard/SoundValue.cpp index 81040d1..4d098d2 100644 --- a/kabc/vcard/SoundValue.cpp +++ b/kabc/vcard/SoundValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardSoundValue.h> | 24 | #include <VCardSoundValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | SoundValue::SoundValue() | 32 | SoundValue::SoundValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | SoundValue::SoundValue(const SoundValue & x) | 37 | SoundValue::SoundValue(const SoundValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | SoundValue::SoundValue(const QCString & s) | 42 | SoundValue::SoundValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | SoundValue & | 47 | SoundValue & |
46 | SoundValue::operator = (SoundValue & x) | 48 | SoundValue::operator = (SoundValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | SoundValue & | 56 | SoundValue & |
55 | SoundValue::operator = (const QCString & s) | 57 | SoundValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | SoundValue::operator == (SoundValue & x) | 64 | SoundValue::operator == (SoundValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | SoundValue::~SoundValue() | 70 | SoundValue::~SoundValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | SoundValue::_parse() | 75 | SoundValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | SoundValue::_assemble() | 80 | SoundValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/SourceParam.cpp b/kabc/vcard/SourceParam.cpp index cd51cbd..8f02113 100644 --- a/kabc/vcard/SourceParam.cpp +++ b/kabc/vcard/SourceParam.cpp | |||
@@ -1,112 +1,114 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardSourceParam.h> | 24 | #include <VCardSourceParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | SourceParam::SourceParam() | 32 | SourceParam::SourceParam() |
31 | :Param(), | 33 | :Param(), |
32 | type_(SourceParam::TypeUnknown) | 34 | type_(SourceParam::TypeUnknown) |
33 | { | 35 | { |
34 | } | 36 | } |
35 | 37 | ||
36 | SourceParam::SourceParam(const SourceParam & x) | 38 | SourceParam::SourceParam(const SourceParam & x) |
37 | :Param(x), | 39 | :Param(x), |
38 | type_(x.type_), | 40 | type_(x.type_), |
39 | par_(x.par_), | 41 | par_(x.par_), |
40 | val_(x.val_) | 42 | val_(x.val_) |
41 | { | 43 | { |
42 | } | 44 | } |
43 | 45 | ||
44 | SourceParam::SourceParam(const QCString & s) | 46 | SourceParam::SourceParam(const Q3CString & s) |
45 | :Param(s), | 47 | :Param(s), |
46 | type_(SourceParam::TypeUnknown) | 48 | type_(SourceParam::TypeUnknown) |
47 | { | 49 | { |
48 | } | 50 | } |
49 | 51 | ||
50 | SourceParam & | 52 | SourceParam & |
51 | SourceParam::operator = (SourceParam & x) | 53 | SourceParam::operator = (SourceParam & x) |
52 | { | 54 | { |
53 | if (*this == x) return *this; | 55 | if (*this == x) return *this; |
54 | type_= x.type(); | 56 | type_= x.type(); |
55 | par_= x.par(); | 57 | par_= x.par(); |
56 | val_= x.val(); | 58 | val_= x.val(); |
57 | 59 | ||
58 | Param::operator = (x); | 60 | Param::operator = (x); |
59 | return *this; | 61 | return *this; |
60 | } | 62 | } |
61 | 63 | ||
62 | SourceParam & | 64 | SourceParam & |
63 | SourceParam::operator = (const QCString & s) | 65 | SourceParam::operator = (const Q3CString & s) |
64 | { | 66 | { |
65 | Param::operator = (s); | 67 | Param::operator = (s); |
66 | return *this; | 68 | return *this; |
67 | } | 69 | } |
68 | 70 | ||
69 | bool | 71 | bool |
70 | SourceParam::operator == (SourceParam & x) | 72 | SourceParam::operator == (SourceParam & x) |
71 | { | 73 | { |
72 | x.parse(); | 74 | x.parse(); |
73 | return false; | 75 | return false; |
74 | } | 76 | } |
75 | 77 | ||
76 | SourceParam::~SourceParam() | 78 | SourceParam::~SourceParam() |
77 | { | 79 | { |
78 | } | 80 | } |
79 | 81 | ||
80 | void | 82 | void |
81 | SourceParam::_parse() | 83 | SourceParam::_parse() |
82 | { | 84 | { |
83 | int i = strRep_.find('='); | 85 | int i = strRep_.find('='); |
84 | if (i == -1) // Invalid | 86 | if (i == -1) // Invalid |
85 | return; | 87 | return; |
86 | 88 | ||
87 | par_ = strRep_.left(i); | 89 | par_ = strRep_.left(i); |
88 | val_ = strRep_.right(strRep_.length() - i - 1); | 90 | val_ = strRep_.right(strRep_.length() - i - 1); |
89 | 91 | ||
90 | if (qstricmp(par_, "VALUE") == 0 && qstricmp(val_, "uri") == 0) | 92 | if (qstricmp(par_, "VALUE") == 0 && qstricmp(val_, "uri") == 0) |
91 | type_ = TypeValue; | 93 | type_ = TypeValue; |
92 | else if (qstricmp(par_, "CONTEXT") == 0 && qstricmp(val_, "word") == 0) | 94 | else if (qstricmp(par_, "CONTEXT") == 0 && qstricmp(val_, "word") == 0) |
93 | type_ = TypeContext; | 95 | type_ = TypeContext; |
94 | else if (qstrnicmp(par_, "X-", 2) == 0) { | 96 | else if (qstrnicmp(par_, "X-", 2) == 0) { |
95 | type_ = TypeX; | 97 | type_ = TypeX; |
96 | } | 98 | } |
97 | else type_ = TypeUnknown; | 99 | else type_ = TypeUnknown; |
98 | 100 | ||
99 | } | 101 | } |
100 | 102 | ||
101 | void | 103 | void |
102 | SourceParam::_assemble() | 104 | SourceParam::_assemble() |
103 | { | 105 | { |
104 | if (type_ == TypeValue) | 106 | if (type_ == TypeValue) |
105 | strRep_ = "VALUE=uri"; | 107 | strRep_ = "VALUE=uri"; |
106 | else if (type_ == TypeContext) | 108 | else if (type_ == TypeContext) |
107 | strRep_ = "CONTEXT=word"; | 109 | strRep_ = "CONTEXT=word"; |
108 | else if (type_ == TypeX) | 110 | else if (type_ == TypeX) |
109 | strRep_ = par_ + "=" + val_; | 111 | strRep_ = par_ + "=" + val_; |
110 | else strRep_ = ""; | 112 | else strRep_ = ""; |
111 | } | 113 | } |
112 | 114 | ||
diff --git a/kabc/vcard/TelParam.cpp b/kabc/vcard/TelParam.cpp index 9d9fe4d..4bc8b6a 100644 --- a/kabc/vcard/TelParam.cpp +++ b/kabc/vcard/TelParam.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardTelParam.h> | 24 | #include <VCardTelParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | TelParam::TelParam() | 32 | TelParam::TelParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | TelParam::TelParam(const TelParam & x) | 37 | TelParam::TelParam(const TelParam & x) |
36 | :Param(x) | 38 | :Param(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | TelParam::TelParam(const QCString & s) | 42 | TelParam::TelParam(const Q3CString & s) |
41 | :Param(s) | 43 | :Param(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | TelParam & | 47 | TelParam & |
46 | TelParam::operator = (TelParam & x) | 48 | TelParam::operator = (TelParam & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Param::operator = (x); | 52 | Param::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | TelParam & | 56 | TelParam & |
55 | TelParam::operator = (const QCString & s) | 57 | TelParam::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Param::operator = (s); | 59 | Param::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | TelParam::operator == (TelParam & x) | 64 | TelParam::operator == (TelParam & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | TelParam::~TelParam() | 70 | TelParam::~TelParam() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | TelParam::_parse() | 75 | TelParam::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | TelParam::_assemble() | 80 | TelParam::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/TelValue.cpp b/kabc/vcard/TelValue.cpp index 349f99a..d9cbf3e 100644 --- a/kabc/vcard/TelValue.cpp +++ b/kabc/vcard/TelValue.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardTelValue.h> | 24 | #include <VCardTelValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | TelValue::TelValue() | 32 | TelValue::TelValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | TelValue::TelValue(const TelValue & x) | 37 | TelValue::TelValue(const TelValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | TelValue::TelValue(const QCString & s) | 42 | TelValue::TelValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | TelValue & | 47 | TelValue & |
46 | TelValue::operator = (TelValue & x) | 48 | TelValue::operator = (TelValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | TelValue & | 56 | TelValue & |
55 | TelValue::operator = (const QCString & s) | 57 | TelValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | TelValue::operator == (TelValue & x) | 64 | TelValue::operator == (TelValue & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | TelValue::~TelValue() | 70 | TelValue::~TelValue() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | TelValue::_parse() | 75 | TelValue::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | TelValue::_assemble() | 80 | TelValue::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/TextBinParam.cpp b/kabc/vcard/TextBinParam.cpp index 66f2946..2866c12 100644 --- a/kabc/vcard/TextBinParam.cpp +++ b/kabc/vcard/TextBinParam.cpp | |||
@@ -1,81 +1,83 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardTextBinParam.h> | 24 | #include <VCardTextBinParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | TextBinParam::TextBinParam() | 32 | TextBinParam::TextBinParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | TextBinParam::TextBinParam(const TextBinParam & x) | 37 | TextBinParam::TextBinParam(const TextBinParam & x) |
36 | :Param(x) | 38 | :Param(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | TextBinParam::TextBinParam(const QCString & s) | 42 | TextBinParam::TextBinParam(const Q3CString & s) |
41 | :Param(s) | 43 | :Param(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | TextBinParam & | 47 | TextBinParam & |
46 | TextBinParam::operator = (TextBinParam & x) | 48 | TextBinParam::operator = (TextBinParam & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Param::operator = (x); | 52 | Param::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | TextBinParam & | 56 | TextBinParam & |
55 | TextBinParam::operator = (const QCString & s) | 57 | TextBinParam::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Param::operator = (s); | 59 | Param::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | TextBinParam::operator == (TextBinParam & x) | 64 | TextBinParam::operator == (TextBinParam & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | return false; | 67 | return false; |
66 | } | 68 | } |
67 | 69 | ||
68 | TextBinParam::~TextBinParam() | 70 | TextBinParam::~TextBinParam() |
69 | { | 71 | { |
70 | } | 72 | } |
71 | 73 | ||
72 | void | 74 | void |
73 | TextBinParam::_parse() | 75 | TextBinParam::_parse() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | TextBinParam::_assemble() | 80 | TextBinParam::_assemble() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
diff --git a/kabc/vcard/TextBinValue.cpp b/kabc/vcard/TextBinValue.cpp index c584009..a3a96ae 100644 --- a/kabc/vcard/TextBinValue.cpp +++ b/kabc/vcard/TextBinValue.cpp | |||
@@ -1,104 +1,106 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <kmdcodec.h> | 24 | #include <kmdcodec.h> |
25 | 25 | ||
26 | #include <VCardTextBinValue.h> | 26 | #include <VCardTextBinValue.h> |
27 | #include <VCardValue.h> | 27 | #include <VCardValue.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3CString> | ||
28 | 30 | ||
29 | using namespace VCARD; | 31 | using namespace VCARD; |
30 | 32 | ||
31 | TextBinValue::TextBinValue() | 33 | TextBinValue::TextBinValue() |
32 | :Value() | 34 | :Value() |
33 | { | 35 | { |
34 | } | 36 | } |
35 | 37 | ||
36 | TextBinValue::TextBinValue(const TextBinValue & x) | 38 | TextBinValue::TextBinValue(const TextBinValue & x) |
37 | :Value(x) | 39 | :Value(x) |
38 | { | 40 | { |
39 | mIsBinary_ = x.mIsBinary_; | 41 | mIsBinary_ = x.mIsBinary_; |
40 | mData_ = x.mData_; | 42 | mData_ = x.mData_; |
41 | mUrl_ = x.mUrl_; | 43 | mUrl_ = x.mUrl_; |
42 | } | 44 | } |
43 | 45 | ||
44 | TextBinValue::TextBinValue(const QCString & s) | 46 | TextBinValue::TextBinValue(const Q3CString & s) |
45 | :Value(s) | 47 | :Value(s) |
46 | { | 48 | { |
47 | } | 49 | } |
48 | 50 | ||
49 | TextBinValue & | 51 | TextBinValue & |
50 | TextBinValue::operator = (TextBinValue & x) | 52 | TextBinValue::operator = (TextBinValue & x) |
51 | { | 53 | { |
52 | if (*this == x) return *this; | 54 | if (*this == x) return *this; |
53 | 55 | ||
54 | mIsBinary_ = x.mIsBinary_; | 56 | mIsBinary_ = x.mIsBinary_; |
55 | mData_ = x.mData_; | 57 | mData_ = x.mData_; |
56 | mUrl_ = x.mUrl_; | 58 | mUrl_ = x.mUrl_; |
57 | 59 | ||
58 | Value::operator = (x); | 60 | Value::operator = (x); |
59 | return *this; | 61 | return *this; |
60 | } | 62 | } |
61 | 63 | ||
62 | TextBinValue & | 64 | TextBinValue & |
63 | TextBinValue::operator = (const QCString & s) | 65 | TextBinValue::operator = (const Q3CString & s) |
64 | { | 66 | { |
65 | Value::operator = (s); | 67 | Value::operator = (s); |
66 | return *this; | 68 | return *this; |
67 | } | 69 | } |
68 | 70 | ||
69 | bool | 71 | bool |
70 | TextBinValue::operator == (TextBinValue & x) | 72 | TextBinValue::operator == (TextBinValue & x) |
71 | { | 73 | { |
72 | x.parse(); | 74 | x.parse(); |
73 | 75 | ||
74 | if ( mIsBinary_ != x.mIsBinary_ ) return false; | 76 | if ( mIsBinary_ != x.mIsBinary_ ) return false; |
75 | if ( mData_ != x.mData_ ) return false; | 77 | if ( mData_ != x.mData_ ) return false; |
76 | if ( mUrl_ != x.mUrl_ ) return false; | 78 | if ( mUrl_ != x.mUrl_ ) return false; |
77 | 79 | ||
78 | return true; | 80 | return true; |
79 | } | 81 | } |
80 | 82 | ||
81 | TextBinValue::~TextBinValue() | 83 | TextBinValue::~TextBinValue() |
82 | { | 84 | { |
83 | } | 85 | } |
84 | 86 | ||
85 | TextBinValue * | 87 | TextBinValue * |
86 | TextBinValue::clone() | 88 | TextBinValue::clone() |
87 | { | 89 | { |
88 | return new TextBinValue( *this ); | 90 | return new TextBinValue( *this ); |
89 | } | 91 | } |
90 | 92 | ||
91 | void | 93 | void |
92 | TextBinValue::_parse() | 94 | TextBinValue::_parse() |
93 | { | 95 | { |
94 | } | 96 | } |
95 | 97 | ||
96 | void | 98 | void |
97 | TextBinValue::_assemble() | 99 | TextBinValue::_assemble() |
98 | { | 100 | { |
99 | if ( mIsBinary_ ) { | 101 | if ( mIsBinary_ ) { |
100 | strRep_ = KCodecs::base64Encode( mData_ ); | 102 | strRep_ = KCodecs::base64Encode( mData_ ); |
101 | } else | 103 | } else |
102 | strRep_ = mUrl_.utf8(); | 104 | strRep_ = mUrl_.utf8(); |
103 | } | 105 | } |
104 | 106 | ||
diff --git a/kabc/vcard/TextListValue.cpp b/kabc/vcard/TextListValue.cpp index c4ac1e3..919f4f7 100644 --- a/kabc/vcard/TextListValue.cpp +++ b/kabc/vcard/TextListValue.cpp | |||
@@ -1,107 +1,109 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardRToken.h> | 24 | #include <VCardRToken.h> |
25 | 25 | ||
26 | #include <VCardTextListValue.h> | 26 | #include <VCardTextListValue.h> |
27 | 27 | ||
28 | #include <VCardValue.h> | 28 | #include <VCardValue.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
29 | 31 | ||
30 | using namespace VCARD; | 32 | using namespace VCARD; |
31 | 33 | ||
32 | TextListValue::TextListValue() | 34 | TextListValue::TextListValue() |
33 | :Value() | 35 | :Value() |
34 | { | 36 | { |
35 | } | 37 | } |
36 | 38 | ||
37 | TextListValue::TextListValue(const TextListValue & x) | 39 | TextListValue::TextListValue(const TextListValue & x) |
38 | :Value(x) | 40 | :Value(x) |
39 | { | 41 | { |
40 | } | 42 | } |
41 | 43 | ||
42 | TextListValue::TextListValue(const QCString & s) | 44 | TextListValue::TextListValue(const Q3CString & s) |
43 | :Value(s) | 45 | :Value(s) |
44 | { | 46 | { |
45 | } | 47 | } |
46 | 48 | ||
47 | TextListValue & | 49 | TextListValue & |
48 | TextListValue::operator = (TextListValue & x) | 50 | TextListValue::operator = (TextListValue & x) |
49 | { | 51 | { |
50 | if (*this == x) return *this; | 52 | if (*this == x) return *this; |
51 | 53 | ||
52 | Value::operator = (x); | 54 | Value::operator = (x); |
53 | return *this; | 55 | return *this; |
54 | } | 56 | } |
55 | 57 | ||
56 | TextListValue & | 58 | TextListValue & |
57 | TextListValue::operator = (const QCString & s) | 59 | TextListValue::operator = (const Q3CString & s) |
58 | { | 60 | { |
59 | Value::operator = (s); | 61 | Value::operator = (s); |
60 | return *this; | 62 | return *this; |
61 | } | 63 | } |
62 | 64 | ||
63 | bool | 65 | bool |
64 | TextListValue::operator == (TextListValue & x) | 66 | TextListValue::operator == (TextListValue & x) |
65 | { | 67 | { |
66 | x.parse(); | 68 | x.parse(); |
67 | return false; | 69 | return false; |
68 | } | 70 | } |
69 | 71 | ||
70 | TextListValue::~TextListValue() | 72 | TextListValue::~TextListValue() |
71 | { | 73 | { |
72 | } | 74 | } |
73 | 75 | ||
74 | void | 76 | void |
75 | TextListValue::_parse() | 77 | TextListValue::_parse() |
76 | { | 78 | { |
77 | RTokenise(strRep_, ";", valueList_); | 79 | RTokenise(strRep_, ";", valueList_); |
78 | } | 80 | } |
79 | 81 | ||
80 | void | 82 | void |
81 | TextListValue::_assemble() | 83 | TextListValue::_assemble() |
82 | { | 84 | { |
83 | bool first(true); | 85 | bool first(true); |
84 | 86 | ||
85 | QStrListIterator it(valueList_); | 87 | Q3StrListIterator it(valueList_); |
86 | 88 | ||
87 | for (; it.current(); ++it) { | 89 | for (; it.current(); ++it) { |
88 | if (!first) strRep_ += ';'; | 90 | if (!first) strRep_ += ';'; |
89 | strRep_ += it.current(); | 91 | strRep_ += it.current(); |
90 | first = false; | 92 | first = false; |
91 | } | 93 | } |
92 | } | 94 | } |
93 | 95 | ||
94 | unsigned int | 96 | unsigned int |
95 | TextListValue::numValues() | 97 | TextListValue::numValues() |
96 | { | 98 | { |
97 | parse(); | 99 | parse(); |
98 | return valueList_.count(); | 100 | return valueList_.count(); |
99 | } | 101 | } |
100 | 102 | ||
101 | QCString | 103 | Q3CString |
102 | TextListValue::value(unsigned int i) | 104 | TextListValue::value(unsigned int i) |
103 | { | 105 | { |
104 | parse(); | 106 | parse(); |
105 | return valueList_.at(i); | 107 | return valueList_.at(i); |
106 | } | 108 | } |
107 | 109 | ||
diff --git a/kabc/vcard/TextParam.cpp b/kabc/vcard/TextParam.cpp index 7c68700..ce6661f 100644 --- a/kabc/vcard/TextParam.cpp +++ b/kabc/vcard/TextParam.cpp | |||
@@ -1,82 +1,84 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardTextParam.h> | 24 | #include <VCardTextParam.h> |
25 | 25 | ||
26 | #include <VCardParam.h> | 26 | #include <VCardParam.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | TextParam::TextParam() | 32 | TextParam::TextParam() |
31 | :Param() | 33 | :Param() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | TextParam::TextParam(const TextParam & x) | 37 | TextParam::TextParam(const TextParam & x) |
36 | :Param(x) | 38 | :Param(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | TextParam::TextParam(const QCString & s) | 42 | TextParam::TextParam(const Q3CString & s) |
41 | :Param(s) | 43 | :Param(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | TextParam & | 47 | TextParam & |
46 | TextParam::operator = (TextParam & x) | 48 | TextParam::operator = (TextParam & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Param::operator = (x); | 52 | Param::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | TextParam & | 56 | TextParam & |
55 | TextParam::operator = (const QCString & s) | 57 | TextParam::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Param::operator = (s); | 59 | Param::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | TextParam::operator == (TextParam & x) | 64 | TextParam::operator == (TextParam & x) |
63 | { | 65 | { |
64 | x.parse(); | 66 | x.parse(); |
65 | 67 | ||
66 | return false; | 68 | return false; |
67 | } | 69 | } |
68 | 70 | ||
69 | TextParam::~TextParam() | 71 | TextParam::~TextParam() |
70 | { | 72 | { |
71 | } | 73 | } |
72 | 74 | ||
73 | void | 75 | void |
74 | TextParam::_parse() | 76 | TextParam::_parse() |
75 | { | 77 | { |
76 | } | 78 | } |
77 | 79 | ||
78 | void | 80 | void |
79 | TextParam::_assemble() | 81 | TextParam::_assemble() |
80 | { | 82 | { |
81 | } | 83 | } |
82 | 84 | ||
diff --git a/kabc/vcard/TextValue.cpp b/kabc/vcard/TextValue.cpp index 09934fa..d0d2996 100644 --- a/kabc/vcard/TextValue.cpp +++ b/kabc/vcard/TextValue.cpp | |||
@@ -1,86 +1,88 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardTextValue.h> | 24 | #include <VCardTextValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | TextValue::TextValue() | 32 | TextValue::TextValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | TextValue::TextValue(const TextValue & x) | 37 | TextValue::TextValue(const TextValue & x) |
36 | :Value(x) | 38 | :Value(x) |
37 | { | 39 | { |
38 | } | 40 | } |
39 | 41 | ||
40 | TextValue::TextValue(const QCString & s) | 42 | TextValue::TextValue(const Q3CString & s) |
41 | :Value(s) | 43 | :Value(s) |
42 | { | 44 | { |
43 | } | 45 | } |
44 | 46 | ||
45 | TextValue & | 47 | TextValue & |
46 | TextValue::operator = (TextValue & x) | 48 | TextValue::operator = (TextValue & x) |
47 | { | 49 | { |
48 | if (*this == x) return *this; | 50 | if (*this == x) return *this; |
49 | 51 | ||
50 | Value::operator = (x); | 52 | Value::operator = (x); |
51 | return *this; | 53 | return *this; |
52 | } | 54 | } |
53 | 55 | ||
54 | TextValue & | 56 | TextValue & |
55 | TextValue::operator = (const QCString & s) | 57 | TextValue::operator = (const Q3CString & s) |
56 | { | 58 | { |
57 | Value::operator = (s); | 59 | Value::operator = (s); |
58 | return *this; | 60 | return *this; |
59 | } | 61 | } |
60 | 62 | ||
61 | bool | 63 | bool |
62 | TextValue::operator == (TextValue & x) | 64 | TextValue::operator == (TextValue & x) |
63 | { | 65 | { |
64 | return strRep_ = x.strRep_; | 66 | return strRep_ == x.strRep_; |
65 | } | 67 | } |
66 | 68 | ||
67 | TextValue::~TextValue() | 69 | TextValue::~TextValue() |
68 | { | 70 | { |
69 | } | 71 | } |
70 | 72 | ||
71 | TextValue * | 73 | TextValue * |
72 | TextValue::clone() | 74 | TextValue::clone() |
73 | { | 75 | { |
74 | return new TextValue( *this ); | 76 | return new TextValue( *this ); |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | TextValue::_parse() | 80 | TextValue::_parse() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
82 | void | 84 | void |
83 | TextValue::_assemble() | 85 | TextValue::_assemble() |
84 | { | 86 | { |
85 | } | 87 | } |
86 | 88 | ||
diff --git a/kabc/vcard/URIValue.cpp b/kabc/vcard/URIValue.cpp index c1d1022..26da7f4 100644 --- a/kabc/vcard/URIValue.cpp +++ b/kabc/vcard/URIValue.cpp | |||
@@ -1,133 +1,135 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardURIValue.h> | 24 | #include <VCardURIValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | URIValue::URIValue() | 32 | URIValue::URIValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | URIValue::URIValue(const QCString & scheme, const QCString & schemeSpecificPart) | 37 | URIValue::URIValue(const Q3CString & scheme, const Q3CString & schemeSpecificPart) |
36 | :Value(), | 38 | :Value(), |
37 | scheme_ (scheme), | 39 | scheme_ (scheme), |
38 | schemeSpecificPart_(schemeSpecificPart) | 40 | schemeSpecificPart_(schemeSpecificPart) |
39 | { | 41 | { |
40 | parsed_ = true; | 42 | parsed_ = true; |
41 | } | 43 | } |
42 | 44 | ||
43 | URIValue::URIValue(const URIValue & x) | 45 | URIValue::URIValue(const URIValue & x) |
44 | : Value (x), | 46 | : Value (x), |
45 | scheme_ (x.scheme_), | 47 | scheme_ (x.scheme_), |
46 | schemeSpecificPart_(x.schemeSpecificPart_) | 48 | schemeSpecificPart_(x.schemeSpecificPart_) |
47 | { | 49 | { |
48 | } | 50 | } |
49 | 51 | ||
50 | URIValue::URIValue(const QCString & s) | 52 | URIValue::URIValue(const Q3CString & s) |
51 | :Value(s) | 53 | :Value(s) |
52 | { | 54 | { |
53 | } | 55 | } |
54 | 56 | ||
55 | URIValue & | 57 | URIValue & |
56 | URIValue::operator = (URIValue & x) | 58 | URIValue::operator = (URIValue & x) |
57 | { | 59 | { |
58 | if (*this == x) return *this; | 60 | if (*this == x) return *this; |
59 | 61 | ||
60 | scheme_ = x.scheme_; | 62 | scheme_ = x.scheme_; |
61 | schemeSpecificPart_= x.schemeSpecificPart_; | 63 | schemeSpecificPart_= x.schemeSpecificPart_; |
62 | 64 | ||
63 | Value::operator = (x); | 65 | Value::operator = (x); |
64 | return *this; | 66 | return *this; |
65 | } | 67 | } |
66 | 68 | ||
67 | URIValue & | 69 | URIValue & |
68 | URIValue::operator = (const QCString & s) | 70 | URIValue::operator = (const Q3CString & s) |
69 | { | 71 | { |
70 | Value::operator = (s); | 72 | Value::operator = (s); |
71 | return *this; | 73 | return *this; |
72 | } | 74 | } |
73 | 75 | ||
74 | bool | 76 | bool |
75 | URIValue::operator == (URIValue & x) | 77 | URIValue::operator == (URIValue & x) |
76 | { | 78 | { |
77 | x.parse(); | 79 | x.parse(); |
78 | return ( | 80 | return ( |
79 | (scheme_ == x.scheme_) && | 81 | (scheme_ == x.scheme_) && |
80 | (schemeSpecificPart_== x.schemeSpecificPart_)); | 82 | (schemeSpecificPart_== x.schemeSpecificPart_)); |
81 | 83 | ||
82 | return false; | 84 | return false; |
83 | } | 85 | } |
84 | 86 | ||
85 | URIValue::~URIValue() | 87 | URIValue::~URIValue() |
86 | { | 88 | { |
87 | } | 89 | } |
88 | 90 | ||
89 | void | 91 | void |
90 | URIValue::_parse() | 92 | URIValue::_parse() |
91 | { | 93 | { |
92 | int split = strRep_.find(':'); | 94 | int split = strRep_.find(':'); |
93 | if (split == -1) | 95 | if (split == -1) |
94 | return; | 96 | return; |
95 | 97 | ||
96 | scheme_ = strRep_.left(split); | 98 | scheme_ = strRep_.left(split); |
97 | schemeSpecificPart_ = strRep_.mid(split + 1); | 99 | schemeSpecificPart_ = strRep_.mid(split + 1); |
98 | } | 100 | } |
99 | 101 | ||
100 | void | 102 | void |
101 | URIValue::_assemble() | 103 | URIValue::_assemble() |
102 | { | 104 | { |
103 | strRep_ = scheme_ + ':' + schemeSpecificPart_; | 105 | strRep_ = scheme_ + ':' + schemeSpecificPart_; |
104 | } | 106 | } |
105 | 107 | ||
106 | QCString | 108 | Q3CString |
107 | URIValue::scheme() | 109 | URIValue::scheme() |
108 | { | 110 | { |
109 | parse(); | 111 | parse(); |
110 | return scheme_; | 112 | return scheme_; |
111 | } | 113 | } |
112 | 114 | ||
113 | QCString | 115 | Q3CString |
114 | URIValue::schemeSpecificPart() | 116 | URIValue::schemeSpecificPart() |
115 | { | 117 | { |
116 | parse(); | 118 | parse(); |
117 | return schemeSpecificPart_; | 119 | return schemeSpecificPart_; |
118 | } | 120 | } |
119 | 121 | ||
120 | void | 122 | void |
121 | URIValue::setScheme(const QCString & s) | 123 | URIValue::setScheme(const Q3CString & s) |
122 | { | 124 | { |
123 | parse(); | 125 | parse(); |
124 | scheme_ = s; | 126 | scheme_ = s; |
125 | } | 127 | } |
126 | 128 | ||
127 | void | 129 | void |
128 | URIValue::setSchemeSpecificPart(const QCString & s) | 130 | URIValue::setSchemeSpecificPart(const Q3CString & s) |
129 | { | 131 | { |
130 | parse(); | 132 | parse(); |
131 | schemeSpecificPart_ = s; | 133 | schemeSpecificPart_ = s; |
132 | } | 134 | } |
133 | 135 | ||
diff --git a/kabc/vcard/UTCValue.cpp b/kabc/vcard/UTCValue.cpp index 374306c..f35d986 100644 --- a/kabc/vcard/UTCValue.cpp +++ b/kabc/vcard/UTCValue.cpp | |||
@@ -1,110 +1,112 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardUTCValue.h> | 24 | #include <VCardUTCValue.h> |
25 | 25 | ||
26 | #include <VCardValue.h> | 26 | #include <VCardValue.h> |
27 | //Added by qt3to4: | ||
28 | #include <Q3CString> | ||
27 | 29 | ||
28 | using namespace VCARD; | 30 | using namespace VCARD; |
29 | 31 | ||
30 | UTCValue::UTCValue() | 32 | UTCValue::UTCValue() |
31 | :Value() | 33 | :Value() |
32 | { | 34 | { |
33 | } | 35 | } |
34 | 36 | ||
35 | UTCValue::UTCValue(const UTCValue & x) | 37 | UTCValue::UTCValue(const UTCValue & x) |
36 | : Value(x),positive_(x.positive_), hour_(x.hour_), minute_(x.minute_) | 38 | : Value(x),positive_(x.positive_), hour_(x.hour_), minute_(x.minute_) |
37 | 39 | ||
38 | { | 40 | { |
39 | } | 41 | } |
40 | 42 | ||
41 | UTCValue::UTCValue(const QCString & s) | 43 | UTCValue::UTCValue(const Q3CString & s) |
42 | :Value(s) | 44 | :Value(s) |
43 | { | 45 | { |
44 | } | 46 | } |
45 | 47 | ||
46 | UTCValue & | 48 | UTCValue & |
47 | UTCValue::operator = (UTCValue & x) | 49 | UTCValue::operator = (UTCValue & x) |
48 | { | 50 | { |
49 | if (*this == x) return *this; | 51 | if (*this == x) return *this; |
50 | 52 | ||
51 | positive_ = x.positive_; | 53 | positive_ = x.positive_; |
52 | hour_ = x.hour_; | 54 | hour_ = x.hour_; |
53 | minute_ = x.minute_; | 55 | minute_ = x.minute_; |
54 | 56 | ||
55 | Value::operator = (x); | 57 | Value::operator = (x); |
56 | return *this; | 58 | return *this; |
57 | } | 59 | } |
58 | 60 | ||
59 | UTCValue & | 61 | UTCValue & |
60 | UTCValue::operator = (const QCString & s) | 62 | UTCValue::operator = (const Q3CString & s) |
61 | { | 63 | { |
62 | Value::operator = (s); | 64 | Value::operator = (s); |
63 | return *this; | 65 | return *this; |
64 | } | 66 | } |
65 | 67 | ||
66 | bool | 68 | bool |
67 | UTCValue::operator == (UTCValue & x) | 69 | UTCValue::operator == (UTCValue & x) |
68 | { | 70 | { |
69 | x.parse(); | 71 | x.parse(); |
70 | 72 | ||
71 | if (positive_ != x.positive_) return false; | 73 | if (positive_ != x.positive_) return false; |
72 | if (hour_ != x.hour_) return false; | 74 | if (hour_ != x.hour_) return false; |
73 | if (minute_ != x.minute_) return false; | 75 | if (minute_ != x.minute_) return false; |
74 | 76 | ||
75 | return true; | 77 | return true; |
76 | } | 78 | } |
77 | 79 | ||
78 | UTCValue::~UTCValue() | 80 | UTCValue::~UTCValue() |
79 | { | 81 | { |
80 | } | 82 | } |
81 | 83 | ||
82 | UTCValue * | 84 | UTCValue * |
83 | UTCValue::clone() | 85 | UTCValue::clone() |
84 | { | 86 | { |
85 | return new UTCValue( *this ); | 87 | return new UTCValue( *this ); |
86 | } | 88 | } |
87 | 89 | ||
88 | void | 90 | void |
89 | UTCValue::_parse() | 91 | UTCValue::_parse() |
90 | { | 92 | { |
91 | if ( strRep_.isEmpty() ) | 93 | if ( strRep_.isEmpty() ) |
92 | return; | 94 | return; |
93 | 95 | ||
94 | positive_ = ( strRep_[0] == '+' ); | 96 | positive_ = ( strRep_[0] == '+' ); |
95 | 97 | ||
96 | int colon = strRep_.find( ':' ); | 98 | int colon = strRep_.find( ':' ); |
97 | 99 | ||
98 | if ( colon == -1 ) // Not valid. | 100 | if ( colon == -1 ) // Not valid. |
99 | return; | 101 | return; |
100 | 102 | ||
101 | hour_= strRep_.mid( 1, 2 ).toInt(); | 103 | hour_= strRep_.mid( 1, 2 ).toInt(); |
102 | minute_= strRep_.right( 2 ).toInt(); | 104 | minute_= strRep_.right( 2 ).toInt(); |
103 | } | 105 | } |
104 | 106 | ||
105 | void | 107 | void |
106 | UTCValue::_assemble() | 108 | UTCValue::_assemble() |
107 | { | 109 | { |
108 | strRep_.sprintf( "%c%.2i:%.2i", (positive_ ? '+' : '-'), hour_, minute_ ); | 110 | strRep_.sprintf( "%c%.2i:%.2i", (positive_ ? '+' : '-'), hour_, minute_ ); |
109 | } | 111 | } |
110 | 112 | ||
diff --git a/kabc/vcard/VCardEntity.cpp b/kabc/vcard/VCardEntity.cpp index a2ff327..bae5385 100644 --- a/kabc/vcard/VCardEntity.cpp +++ b/kabc/vcard/VCardEntity.cpp | |||
@@ -1,175 +1,177 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qregexp.h> | 24 | #include <qregexp.h> |
25 | #include <qdatetime.h> | 25 | #include <qdatetime.h> |
26 | //Added by qt3to4: | ||
27 | #include <Q3CString> | ||
26 | 28 | ||
27 | #include <VCardDefines.h> | 29 | #include <VCardDefines.h> |
28 | #include <VCardVCardEntity.h> | 30 | #include <VCardVCardEntity.h> |
29 | 31 | ||
30 | using namespace VCARD; | 32 | using namespace VCARD; |
31 | 33 | ||
32 | VCardEntity::VCardEntity() | 34 | VCardEntity::VCardEntity() |
33 | :Entity() | 35 | :Entity() |
34 | { | 36 | { |
35 | cardList_.setAutoDelete( TRUE ); | 37 | cardList_.setAutoDelete( TRUE ); |
36 | } | 38 | } |
37 | 39 | ||
38 | VCardEntity::VCardEntity(const VCardEntity & x) | 40 | VCardEntity::VCardEntity(const VCardEntity & x) |
39 | :Entity(x) | 41 | :Entity(x) |
40 | { | 42 | { |
41 | cardList_.setAutoDelete( TRUE ); | 43 | cardList_.setAutoDelete( TRUE ); |
42 | } | 44 | } |
43 | 45 | ||
44 | VCardEntity::VCardEntity(const QCString & s) | 46 | VCardEntity::VCardEntity(const Q3CString & s) |
45 | :Entity(s) | 47 | :Entity(s) |
46 | { | 48 | { |
47 | cardList_.setAutoDelete( TRUE ); | 49 | cardList_.setAutoDelete( TRUE ); |
48 | } | 50 | } |
49 | 51 | ||
50 | VCardEntity & | 52 | VCardEntity & |
51 | VCardEntity::operator = (VCardEntity & x) | 53 | VCardEntity::operator = (VCardEntity & x) |
52 | { | 54 | { |
53 | if (*this == x) return *this; | 55 | if (*this == x) return *this; |
54 | 56 | ||
55 | Entity::operator = (x); | 57 | Entity::operator = (x); |
56 | return *this; | 58 | return *this; |
57 | } | 59 | } |
58 | 60 | ||
59 | VCardEntity & | 61 | VCardEntity & |
60 | VCardEntity::operator = (const QCString & s) | 62 | VCardEntity::operator = (const Q3CString & s) |
61 | { | 63 | { |
62 | Entity::operator = (s); | 64 | Entity::operator = (s); |
63 | return *this; | 65 | return *this; |
64 | } | 66 | } |
65 | 67 | ||
66 | bool | 68 | bool |
67 | VCardEntity::operator == (VCardEntity & x) | 69 | VCardEntity::operator == (VCardEntity & x) |
68 | { | 70 | { |
69 | x.parse(); | 71 | x.parse(); |
70 | return false; | 72 | return false; |
71 | } | 73 | } |
72 | 74 | ||
73 | VCardEntity::~VCardEntity() | 75 | VCardEntity::~VCardEntity() |
74 | { | 76 | { |
75 | } | 77 | } |
76 | 78 | ||
77 | void | 79 | void |
78 | VCardEntity::_parse() | 80 | VCardEntity::_parse() |
79 | { | 81 | { |
80 | #if 0 | 82 | #if 0 |
81 | QTime tim; | 83 | QTime tim; |
82 | tim.start(); | 84 | tim.start(); |
83 | int num = 0; | 85 | int num = 0; |
84 | // old code | 86 | // old code |
85 | vDebug("parse"); | 87 | vDebug("parse"); |
86 | QCString s(strRep_); | 88 | Q3CString s(strRep_); |
87 | 89 | ||
88 | int i = s.find(QRegExp("BEGIN:VCARD", false)); | 90 | int i = s.find(QRegExp("BEGIN:VCARD", false)); |
89 | 91 | ||
90 | while (i != -1) { | 92 | while (i != -1) { |
91 | 93 | ||
92 | i = s.find(QRegExp("BEGIN:VCARD", false), 11); | 94 | i = s.find(QRegExp("BEGIN:VCARD", false), 11); |
93 | 95 | ||
94 | QCString cardStr(s.left(i)); | 96 | Q3CString cardStr(s.left(i)); |
95 | 97 | ||
96 | VCard * v = new VCard(cardStr); | 98 | VCard * v = new VCard(cardStr); |
97 | 99 | ||
98 | cardList_.append(v); | 100 | cardList_.append(v); |
99 | 101 | ||
100 | v->parse(); | 102 | v->parse(); |
101 | 103 | ||
102 | s.remove(0, i); | 104 | s.remove(0, i); |
103 | } | 105 | } |
104 | 106 | ||
105 | #else | 107 | #else |
106 | // this code is up to 17 (!) times faster | 108 | // this code is up to 17 (!) times faster |
107 | int start = 0; | 109 | int start = 0; |
108 | QTime tim; | 110 | QTime tim; |
109 | tim.start(); | 111 | tim.start(); |
110 | int i = 11; | 112 | int i = 11; |
111 | int len = strRep_.length(); | 113 | int len = strRep_.length(); |
112 | int num = 0; | 114 | int num = 0; |
113 | while (i < len ) { | 115 | while (i < len ) { |
114 | while( i < len ) { | 116 | while( i < len ) { |
115 | int add = 1; | 117 | int add = 1; |
116 | if ( strRep_.at(i) == 'B' ) { | 118 | if ( strRep_.at(i) == 'B' ) { |
117 | if ( i+add < len && strRep_.at(i+add++) == 'E') | 119 | if ( i+add < len && strRep_.at(i+add++) == 'E') |
118 | if ( i+add < len && strRep_.at(i+add++) == 'G') | 120 | if ( i+add < len && strRep_.at(i+add++) == 'G') |
119 | if ( i+add < len && strRep_.at(i+add++) == 'I') | 121 | if ( i+add < len && strRep_.at(i+add++) == 'I') |
120 | if ( i+add < len && strRep_.at(i+add++) == 'N') | 122 | if ( i+add < len && strRep_.at(i+add++) == 'N') |
121 | if ( i+add < len && strRep_.at(i+add++) == ':') | 123 | if ( i+add < len && strRep_.at(i+add++) == ':') |
122 | if ( i+add < len && strRep_.at(i+add++) == 'V') | 124 | if ( i+add < len && strRep_.at(i+add++) == 'V') |
123 | if ( i+add < len && strRep_.at(i+add++) == 'C') | 125 | if ( i+add < len && strRep_.at(i+add++) == 'C') |
124 | if ( i+add < len && strRep_.at(i+add++) == 'A') | 126 | if ( i+add < len && strRep_.at(i+add++) == 'A') |
125 | if ( i+add < len && strRep_.at(i+add++) == 'R') | 127 | if ( i+add < len && strRep_.at(i+add++) == 'R') |
126 | if ( i+add < len && strRep_.at(i+add++) == 'D') | 128 | if ( i+add < len && strRep_.at(i+add++) == 'D') |
127 | if ( i+add < len && (strRep_.at(i+add) == '\r' || strRep_.at(i+add) == '\n' )) | 129 | if ( i+add < len && (strRep_.at(i+add) == '\r' || strRep_.at(i+add) == '\n' )) |
128 | break; | 130 | break; |
129 | } | 131 | } |
130 | ++i; | 132 | ++i; |
131 | } | 133 | } |
132 | if ( i <= len ) { | 134 | if ( i <= len ) { |
133 | ++num; | 135 | ++num; |
134 | char* dat = strRep_.data()+start; | 136 | char* dat = strRep_.data()+start; |
135 | VCard * v = new VCard( QCString ( dat,i-start ) ); | 137 | VCard * v = new VCard( Q3CString ( dat,i-start ) ); |
136 | start = i; | 138 | start = i; |
137 | cardList_.append(v); | 139 | cardList_.append(v); |
138 | v->parse(); | 140 | v->parse(); |
139 | } | 141 | } |
140 | i+= 11; | 142 | i+= 11; |
141 | } | 143 | } |
142 | #endif | 144 | #endif |
143 | //qDebug("***time %d found %d", tim.elapsed(), num); | 145 | //qDebug("***time %d found %d", tim.elapsed(), num); |
144 | } | 146 | } |
145 | 147 | ||
146 | void | 148 | void |
147 | VCardEntity::_assemble() | 149 | VCardEntity::_assemble() |
148 | { | 150 | { |
149 | VCardListIterator it(cardList_); | 151 | VCardListIterator it(cardList_); |
150 | 152 | ||
151 | for (; it.current(); ++it) | 153 | for (; it.current(); ++it) |
152 | strRep_ += it.current()->asString() + "\r\n"; // One CRLF for luck. | 154 | strRep_ += it.current()->asString() + "\r\n"; // One CRLF for luck. |
153 | } | 155 | } |
154 | 156 | ||
155 | VCardList & | 157 | VCardList & |
156 | VCardEntity::cardList() | 158 | VCardEntity::cardList() |
157 | { | 159 | { |
158 | parse(); | 160 | parse(); |
159 | return cardList_; | 161 | return cardList_; |
160 | } | 162 | } |
161 | 163 | ||
162 | void | 164 | void |
163 | VCardEntity::setCardList(const VCardList & l) | 165 | VCardEntity::setCardList(const VCardList & l) |
164 | { | 166 | { |
165 | parse(); | 167 | parse(); |
166 | //UScardList_ = l; | 168 | //UScardList_ = l; |
167 | VCardListIterator it(l); | 169 | VCardListIterator it(l); |
168 | 170 | ||
169 | for (; it.current(); ++it) { | 171 | for (; it.current(); ++it) { |
170 | VCard* v = new VCard(*it.current()); | 172 | VCard* v = new VCard(*it.current()); |
171 | cardList_.append(v); | 173 | cardList_.append(v); |
172 | } | 174 | } |
173 | 175 | ||
174 | } | 176 | } |
175 | 177 | ||
diff --git a/kabc/vcard/VCardv.cpp b/kabc/vcard/VCardv.cpp index bad2ef1..5dd675d 100644 --- a/kabc/vcard/VCardv.cpp +++ b/kabc/vcard/VCardv.cpp | |||
@@ -1,294 +1,295 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <qcstring.h> | 24 | #include <q3cstring.h> |
25 | #include <qstrlist.h> | 25 | #include <q3strlist.h> |
26 | #include <qstringlist.h> | 26 | #include <qstringlist.h> |
27 | #include <qstring.h> | 27 | #include <qstring.h> |
28 | #include <qvaluelist.h> | 28 | #include <q3valuelist.h> |
29 | 29 | ||
30 | #include <VCardEntity.h> | 30 | #include <VCardEntity.h> |
31 | #include <VCardVCard.h> | 31 | #include <VCardVCard.h> |
32 | #include <VCardContentLine.h> | 32 | #include <VCardContentLine.h> |
33 | #include <VCardRToken.h> | 33 | #include <VCardRToken.h> |
34 | 34 | ||
35 | #include <VCardDefines.h> | 35 | #include <VCardDefines.h> |
36 | 36 | ||
37 | using namespace VCARD; | 37 | using namespace VCARD; |
38 | 38 | ||
39 | VCard::VCard() | 39 | VCard::VCard() |
40 | :Entity() | 40 | :Entity() |
41 | { | 41 | { |
42 | contentLineList_.setAutoDelete( TRUE ); | 42 | contentLineList_.setAutoDelete( TRUE ); |
43 | } | 43 | } |
44 | 44 | ||
45 | VCard::VCard(const VCard & x) | 45 | VCard::VCard(const VCard & x) |
46 | :Entity(x), | 46 | :Entity(x), |
47 | group_(x.group_) | 47 | group_(x.group_) |
48 | { | 48 | { |
49 | contentLineList_.setAutoDelete( TRUE ); | 49 | contentLineList_.setAutoDelete( TRUE ); |
50 | 50 | ||
51 | QPtrListIterator<ContentLine> it(x.contentLineList_); | 51 | Q3PtrListIterator<ContentLine> it(x.contentLineList_); |
52 | for (; it.current(); ++it) { | 52 | for (; it.current(); ++it) { |
53 | ContentLine * c = new ContentLine(*it.current()); | 53 | ContentLine * c = new ContentLine(*it.current()); |
54 | contentLineList_.append(c); | 54 | contentLineList_.append(c); |
55 | } | 55 | } |
56 | 56 | ||
57 | } | 57 | } |
58 | 58 | ||
59 | VCard::VCard(const QCString & s) | 59 | VCard::VCard(const Q3CString & s) |
60 | :Entity(s) | 60 | :Entity(s) |
61 | { | 61 | { |
62 | contentLineList_.setAutoDelete( TRUE ); | 62 | contentLineList_.setAutoDelete( TRUE ); |
63 | } | 63 | } |
64 | 64 | ||
65 | VCard & | 65 | VCard & |
66 | VCard::operator = (VCard & x) | 66 | VCard::operator = (VCard & x) |
67 | { | 67 | { |
68 | if (*this == x) return *this; | 68 | if (*this == x) return *this; |
69 | 69 | ||
70 | group_ = x.group(); | 70 | group_ = x.group(); |
71 | QPtrListIterator<ContentLine> it(x.contentLineList_); | 71 | Q3PtrListIterator<ContentLine> it(x.contentLineList_); |
72 | for (; it.current(); ++it) { | 72 | for (; it.current(); ++it) { |
73 | ContentLine * c = new ContentLine(*it.current()); | 73 | ContentLine * c = new ContentLine(*it.current()); |
74 | contentLineList_.append(c); | 74 | contentLineList_.append(c); |
75 | } | 75 | } |
76 | 76 | ||
77 | Entity::operator = (x); | 77 | Entity::operator = (x); |
78 | return *this; | 78 | return *this; |
79 | } | 79 | } |
80 | 80 | ||
81 | VCard & | 81 | VCard & |
82 | VCard::operator = (const QCString & s) | 82 | VCard::operator = (const Q3CString & s) |
83 | { | 83 | { |
84 | Entity::operator = (s); | 84 | Entity::operator = (s); |
85 | return *this; | 85 | return *this; |
86 | } | 86 | } |
87 | 87 | ||
88 | bool | 88 | bool |
89 | VCard::operator == (VCard & x) | 89 | VCard::operator == (VCard & x) |
90 | { | 90 | { |
91 | x.parse(); | 91 | x.parse(); |
92 | return false; | 92 | return false; |
93 | } | 93 | } |
94 | 94 | ||
95 | VCard::~VCard() | 95 | VCard::~VCard() |
96 | { | 96 | { |
97 | } | 97 | } |
98 | 98 | ||
99 | void | 99 | void |
100 | VCard::_parse() | 100 | VCard::_parse() |
101 | { | 101 | { |
102 | 102 | ||
103 | QStringList l; | 103 | QStringList l; |
104 | QStrList sl; | 104 | Q3StrList sl; |
105 | 105 | ||
106 | RTokenise(strRep_, "\r\n", sl); | 106 | RTokenise(strRep_, "\r\n", sl); |
107 | 107 | ||
108 | if (sl.count() < 3) { // Invalid VCARD ! | 108 | if (sl.count() < 3) { // Invalid VCARD ! |
109 | //qDebug("invalid vcard "); | 109 | //qDebug("invalid vcard "); |
110 | return; | 110 | return; |
111 | } | 111 | } |
112 | l = QStringList::fromStrList( sl ); | 112 | for(Q3StrList::iterator i=sl.begin();i!=sl.end();++i) |
113 | l.push_back(*i); | ||
113 | // Get the first line | 114 | // Get the first line |
114 | QString beginLine = l[0].stripWhiteSpace(); | 115 | QString beginLine = l[0].stripWhiteSpace(); |
115 | 116 | ||
116 | // Remove extra blank lines | 117 | // Remove extra blank lines |
117 | while (l.last().isEmpty()) | 118 | while (l.last().isEmpty()) |
118 | l.remove(l.last()); | 119 | l.remove(l.last()); |
119 | 120 | ||
120 | // Now we know this is the last line | 121 | // Now we know this is the last line |
121 | QString endLine = l.last(); | 122 | QString endLine = l.last(); |
122 | 123 | ||
123 | // Trash the first and last lines as we have seen them. | 124 | // Trash the first and last lines as we have seen them. |
124 | l.remove(l.begin()); | 125 | l.remove(l.begin()); |
125 | l.remove(l.last()); | 126 | l.remove(l.last()); |
126 | 127 | ||
127 | /////////////////////////////////////////////////////////////// | 128 | /////////////////////////////////////////////////////////////// |
128 | // FIRST LINE | 129 | // FIRST LINE |
129 | 130 | ||
130 | int split = beginLine.find(':'); | 131 | int split = beginLine.find(':'); |
131 | 132 | ||
132 | if (split == -1) { // invalid, no BEGIN | 133 | if (split == -1) { // invalid, no BEGIN |
133 | vDebug("No split"); | 134 | vDebug("No split"); |
134 | return; | 135 | return; |
135 | } | 136 | } |
136 | 137 | ||
137 | QString firstPart(beginLine.left(split)); | 138 | QString firstPart(beginLine.left(split)); |
138 | QString valuePart(beginLine.mid(split + 1)); | 139 | QString valuePart(beginLine.mid(split + 1)); |
139 | 140 | ||
140 | split = firstPart.find('.'); | 141 | split = firstPart.find('.'); |
141 | 142 | ||
142 | if (split != -1) { | 143 | if (split != -1) { |
143 | group_ = firstPart.left(split); | 144 | group_ = firstPart.left(split); |
144 | firstPart= firstPart.right(firstPart.length() - split - 1); | 145 | firstPart= firstPart.right(firstPart.length() - split - 1); |
145 | } | 146 | } |
146 | 147 | ||
147 | if (firstPart.left(5) != "BEGIN" ) { // No BEGIN ! | 148 | if (firstPart.left(5) != "BEGIN" ) { // No BEGIN ! |
148 | qDebug("no BEGIN in vcard "); | 149 | qDebug("no BEGIN in vcard "); |
149 | return; | 150 | return; |
150 | } | 151 | } |
151 | 152 | ||
152 | if (valuePart.left(5) != "VCARD") { // Not a vcard ! | 153 | if (valuePart.left(5) != "VCARD") { // Not a vcard ! |
153 | qDebug("not a VCARD "); | 154 | qDebug("not a VCARD "); |
154 | return; | 155 | return; |
155 | } | 156 | } |
156 | 157 | ||
157 | /////////////////////////////////////////////////////////////// | 158 | /////////////////////////////////////////////////////////////// |
158 | // CONTENT LINES | 159 | // CONTENT LINES |
159 | // | 160 | // |
160 | vDebug("Content lines"); | 161 | vDebug("Content lines"); |
161 | 162 | ||
162 | // Handle folded lines. | 163 | // Handle folded lines. |
163 | 164 | ||
164 | QStringList refolded; | 165 | QStringList refolded; |
165 | 166 | ||
166 | 167 | ||
167 | QStringList::Iterator it = l.begin(); | 168 | QStringList::Iterator it = l.begin(); |
168 | 169 | ||
169 | QString cur; | 170 | QString cur; |
170 | 171 | ||
171 | for (; it != l.end(); ++it) { | 172 | for (; it != l.end(); ++it) { |
172 | cur = (*it); | 173 | cur = (*it); |
173 | ++it; | 174 | ++it; |
174 | while ( it!= l.end() && (*it).at(0) == ' '&& (*it).length()!= 1) { | 175 | while ( it!= l.end() && (*it).at(0) == ' '&& (*it).length()!= 1) { |
175 | cur += (*it).mid(1) ; | 176 | cur += (*it).mid(1) ; |
176 | ++it; | 177 | ++it; |
177 | } | 178 | } |
178 | --it; | 179 | --it; |
179 | refolded.append(cur); | 180 | refolded.append(cur); |
180 | } | 181 | } |
181 | QStringList::Iterator it2 = refolded.begin(); | 182 | QStringList::Iterator it2 = refolded.begin(); |
182 | for (; it2 != refolded.end(); ++it2) { | 183 | for (; it2 != refolded.end(); ++it2) { |
183 | ContentLine * cl = new ContentLine(QCString((*it2).latin1())); | 184 | ContentLine * cl = new ContentLine(Q3CString((*it2).latin1())); |
184 | cl->parse(); | 185 | cl->parse(); |
185 | if (cl->value() == 0) | 186 | if (cl->value() == 0) |
186 | { | 187 | { |
187 | qDebug("Content line could not be parsed. Discarded: %s", (*it2).latin1()); | 188 | qDebug("Content line could not be parsed. Discarded: %s", (*it2).latin1()); |
188 | delete cl; | 189 | delete cl; |
189 | } | 190 | } |
190 | else | 191 | else |
191 | contentLineList_.append(cl); | 192 | contentLineList_.append(cl); |
192 | } | 193 | } |
193 | 194 | ||
194 | /////////////////////////////////////////////////////////////// | 195 | /////////////////////////////////////////////////////////////// |
195 | // LAST LINE | 196 | // LAST LINE |
196 | 197 | ||
197 | 198 | ||
198 | // LR: sorry, but the remaining code in this method makes no sense | 199 | // LR: sorry, but the remaining code in this method makes no sense |
199 | 200 | ||
200 | #if 0 | 201 | #if 0 |
201 | split = endLine.find(':'); | 202 | split = endLine.find(':'); |
202 | 203 | ||
203 | if (split == -1) // invalid, no END | 204 | if (split == -1) // invalid, no END |
204 | return; | 205 | return; |
205 | 206 | ||
206 | firstPart = endLine.left(split); | 207 | firstPart = endLine.left(split); |
207 | valuePart = endLine.right(firstPart.length() - split - 1); | 208 | valuePart = endLine.right(firstPart.length() - split - 1); |
208 | 209 | ||
209 | split = firstPart.find('.'); | 210 | split = firstPart.find('.'); |
210 | 211 | ||
211 | if (split != -1) { | 212 | if (split != -1) { |
212 | group_ = firstPart.left(split); | 213 | group_ = firstPart.left(split); |
213 | firstPart= firstPart.right(firstPart.length() - split - 1); | 214 | firstPart= firstPart.right(firstPart.length() - split - 1); |
214 | } | 215 | } |
215 | 216 | ||
216 | if (qstricmp(firstPart, "END") != 0) // No END ! | 217 | if (qstricmp(firstPart, "END") != 0) // No END ! |
217 | return; | 218 | return; |
218 | 219 | ||
219 | if (qstricmp(valuePart, "VCARD") != 0) // Not a vcard ! | 220 | if (qstricmp(valuePart, "VCARD") != 0) // Not a vcard ! |
220 | return; | 221 | return; |
221 | #endif | 222 | #endif |
222 | } | 223 | } |
223 | 224 | ||
224 | void | 225 | void |
225 | VCard::_assemble() | 226 | VCard::_assemble() |
226 | { | 227 | { |
227 | vDebug("Assembling vcard"); | 228 | vDebug("Assembling vcard"); |
228 | strRep_ = "BEGIN:VCARD\r\n"; | 229 | strRep_ = "BEGIN:VCARD\r\n"; |
229 | strRep_ += "VERSION:3.0\r\n"; | 230 | strRep_ += "VERSION:3.0\r\n"; |
230 | 231 | ||
231 | QPtrListIterator<ContentLine> it(contentLineList_); | 232 | Q3PtrListIterator<ContentLine> it(contentLineList_); |
232 | 233 | ||
233 | for (; it.current(); ++it) | 234 | for (; it.current(); ++it) |
234 | strRep_ += it.current()->asString() + "\r\n"; | 235 | strRep_ += it.current()->asString() + "\r\n"; |
235 | 236 | ||
236 | strRep_ += "END:VCARD\r\n"; | 237 | strRep_ += "END:VCARD\r\n"; |
237 | } | 238 | } |
238 | 239 | ||
239 | bool | 240 | bool |
240 | VCard::has(EntityType t) | 241 | VCard::has(EntityType t) |
241 | { | 242 | { |
242 | parse(); | 243 | parse(); |
243 | return contentLine(t) == 0 ? false : true; | 244 | return contentLine(t) == 0 ? false : true; |
244 | } | 245 | } |
245 | 246 | ||
246 | bool | 247 | bool |
247 | VCard::has(const QCString & s) | 248 | VCard::has(const Q3CString & s) |
248 | { | 249 | { |
249 | parse(); | 250 | parse(); |
250 | return contentLine(s) == 0 ? false : true; | 251 | return contentLine(s) == 0 ? false : true; |
251 | } | 252 | } |
252 | 253 | ||
253 | void | 254 | void |
254 | VCard::add(const ContentLine & cl) | 255 | VCard::add(const ContentLine & cl) |
255 | { | 256 | { |
256 | parse(); | 257 | parse(); |
257 | ContentLine * c = new ContentLine(cl); | 258 | ContentLine * c = new ContentLine(cl); |
258 | contentLineList_.append(c); | 259 | contentLineList_.append(c); |
259 | } | 260 | } |
260 | 261 | ||
261 | void | 262 | void |
262 | VCard::add(const QCString & s) | 263 | VCard::add(const Q3CString & s) |
263 | { | 264 | { |
264 | parse(); | 265 | parse(); |
265 | ContentLine * c = new ContentLine(s); | 266 | ContentLine * c = new ContentLine(s); |
266 | contentLineList_.append(c); | 267 | contentLineList_.append(c); |
267 | } | 268 | } |
268 | 269 | ||
269 | ContentLine * | 270 | ContentLine * |
270 | VCard::contentLine(EntityType t) | 271 | VCard::contentLine(EntityType t) |
271 | { | 272 | { |
272 | parse(); | 273 | parse(); |
273 | QPtrListIterator<ContentLine> it(contentLineList_); | 274 | Q3PtrListIterator<ContentLine> it(contentLineList_); |
274 | 275 | ||
275 | for (; it.current(); ++it) | 276 | for (; it.current(); ++it) |
276 | if (it.current()->entityType() == t) | 277 | if (it.current()->entityType() == t) |
277 | return it.current(); | 278 | return it.current(); |
278 | 279 | ||
279 | return 0; | 280 | return 0; |
280 | } | 281 | } |
281 | 282 | ||
282 | ContentLine * | 283 | ContentLine * |
283 | VCard::contentLine(const QCString & s) | 284 | VCard::contentLine(const Q3CString & s) |
284 | { | 285 | { |
285 | parse(); | 286 | parse(); |
286 | QPtrListIterator<ContentLine> it(contentLineList_); | 287 | Q3PtrListIterator<ContentLine> it(contentLineList_); |
287 | 288 | ||
288 | for (; it.current(); ++it) | 289 | for (; it.current(); ++it) |
289 | if (it.current()->entityType() == EntityNameToEntityType(s)) | 290 | if (it.current()->entityType() == EntityNameToEntityType(s)) |
290 | return it.current(); | 291 | return it.current(); |
291 | 292 | ||
292 | return 0; | 293 | return 0; |
293 | } | 294 | } |
294 | 295 | ||
diff --git a/kabc/vcard/Value.cpp b/kabc/vcard/Value.cpp index 1978af2..3a4d406 100644 --- a/kabc/vcard/Value.cpp +++ b/kabc/vcard/Value.cpp | |||
@@ -1,82 +1,84 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #include <VCardEntity.h> | 24 | #include <VCardEntity.h> |
25 | #include <VCardValue.h> | 25 | #include <VCardValue.h> |
26 | //Added by qt3to4: | ||
27 | #include <Q3CString> | ||
26 | 28 | ||
27 | using namespace VCARD; | 29 | using namespace VCARD; |
28 | 30 | ||
29 | Value::Value() | 31 | Value::Value() |
30 | :Entity() | 32 | :Entity() |
31 | { | 33 | { |
32 | } | 34 | } |
33 | 35 | ||
34 | Value::Value(const Value & x) | 36 | Value::Value(const Value & x) |
35 | :Entity(x) | 37 | :Entity(x) |
36 | { | 38 | { |
37 | } | 39 | } |
38 | 40 | ||
39 | Value::Value(const QCString & s) | 41 | Value::Value(const Q3CString & s) |
40 | :Entity(s) | 42 | :Entity(s) |
41 | { | 43 | { |
42 | } | 44 | } |
43 | 45 | ||
44 | Value & | 46 | Value & |
45 | Value::operator = (Value & x) | 47 | Value::operator = (Value & x) |
46 | { | 48 | { |
47 | if (*this == x) return *this; | 49 | if (*this == x) return *this; |
48 | 50 | ||
49 | Entity::operator = (x); | 51 | Entity::operator = (x); |
50 | return *this; | 52 | return *this; |
51 | } | 53 | } |
52 | 54 | ||
53 | Value & | 55 | Value & |
54 | Value::operator = (const QCString & s) | 56 | Value::operator = (const Q3CString & s) |
55 | { | 57 | { |
56 | Entity::operator = (s); | 58 | Entity::operator = (s); |
57 | return *this; | 59 | return *this; |
58 | } | 60 | } |
59 | 61 | ||
60 | bool | 62 | bool |
61 | Value::operator == (Value & x) | 63 | Value::operator == (Value & x) |
62 | { | 64 | { |
63 | x.parse(); | 65 | x.parse(); |
64 | return false; | 66 | return false; |
65 | } | 67 | } |
66 | 68 | ||
67 | Value::~Value() | 69 | Value::~Value() |
68 | { | 70 | { |
69 | } | 71 | } |
70 | 72 | ||
71 | void | 73 | void |
72 | Value::_parse() | 74 | Value::_parse() |
73 | { | 75 | { |
74 | } | 76 | } |
75 | 77 | ||
76 | void | 78 | void |
77 | Value::_assemble() | 79 | Value::_assemble() |
78 | { | 80 | { |
79 | //USvDebug("Value::_assemble()"); | 81 | //USvDebug("Value::_assemble()"); |
80 | qDebug("Value::_assemble()"); | 82 | qDebug("Value::_assemble()"); |
81 | } | 83 | } |
82 | 84 | ||
diff --git a/kabc/vcard/include/VCardAdrParam.h b/kabc/vcard/include/VCardAdrParam.h index 89dcb64..6456624 100644 --- a/kabc/vcard/include/VCardAdrParam.h +++ b/kabc/vcard/include/VCardAdrParam.h | |||
@@ -1,64 +1,64 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef ADRPARAM_H | 24 | #ifndef ADRPARAM_H |
25 | #define ADRPARAM_H | 25 | #define ADRPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qstrlist.h> | 28 | #include <q3strlist.h> |
29 | 29 | ||
30 | #include <VCardParam.h> | 30 | #include <VCardParam.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class AdrParam : public Param | 35 | class AdrParam : public Param |
36 | { | 36 | { |
37 | 37 | ||
38 | #include "AdrParam-generated.h" | 38 | #include "AdrParam-generated.h" |
39 | 39 | ||
40 | QStrList adrTypeList() | 40 | Q3StrList adrTypeList() |
41 | { parse(); return adrTypeList_; } | 41 | { parse(); return adrTypeList_; } |
42 | 42 | ||
43 | QCString textParam() | 43 | Q3CString textParam() |
44 | { parse(); return textParam_; } | 44 | { parse(); return textParam_; } |
45 | 45 | ||
46 | void setAdrTypeList(const QStrList & l) | 46 | void setAdrTypeList(const Q3StrList & l) |
47 | { adrTypeList_ = l; assembled_ = false; } | 47 | { adrTypeList_ = l; assembled_ = false; } |
48 | 48 | ||
49 | void setTextParam(const QCString & s) | 49 | void setTextParam(const Q3CString & s) |
50 | { textParam_ = s; assembled_ = false; } | 50 | { textParam_ = s; assembled_ = false; } |
51 | 51 | ||
52 | enum AdrType { | 52 | enum AdrType { |
53 | AdrDom, AdrIntl, AdrPostal, AdrParcel, AdrHome, AdrWork, AdrPref, | 53 | AdrDom, AdrIntl, AdrPostal, AdrParcel, AdrHome, AdrWork, AdrPref, |
54 | AdrIANA, AdrX | 54 | AdrIANA, AdrX |
55 | }; | 55 | }; |
56 | 56 | ||
57 | private: | 57 | private: |
58 | 58 | ||
59 | QStrListadrTypeList_; | 59 | Q3StrListadrTypeList_; |
60 | QCStringtextParam_; | 60 | Q3CStringtextParam_; |
61 | }; | 61 | }; |
62 | } | 62 | } |
63 | 63 | ||
64 | #endif | 64 | #endif |
diff --git a/kabc/vcard/include/VCardAdrValue.h b/kabc/vcard/include/VCardAdrValue.h index 0731924..14ddb02 100644 --- a/kabc/vcard/include/VCardAdrValue.h +++ b/kabc/vcard/include/VCardAdrValue.h | |||
@@ -1,83 +1,85 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef ADRVALUE_H | 24 | #ifndef ADRVALUE_H |
25 | #define ADRVALUE_H | 25 | #define ADRVALUE_H |
26 | 26 | ||
27 | #include <qstrlist.h> | 27 | #include <q3strlist.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3CString> | ||
28 | #include <VCardValue.h> | 30 | #include <VCardValue.h> |
29 | 31 | ||
30 | namespace VCARD | 32 | namespace VCARD |
31 | { | 33 | { |
32 | 34 | ||
33 | class AdrValue : public Value | 35 | class AdrValue : public Value |
34 | { | 36 | { |
35 | 37 | ||
36 | #include "AdrValue-generated.h" | 38 | #include "AdrValue-generated.h" |
37 | 39 | ||
38 | AdrValue *clone(); | 40 | AdrValue *clone(); |
39 | 41 | ||
40 | void setPOBox(const QCString & s) | 42 | void setPOBox(const Q3CString & s) |
41 | { poBox_ = s; assembled_ = false; } | 43 | { poBox_ = s; assembled_ = false; } |
42 | 44 | ||
43 | void setExtAddress(const QCString & s) | 45 | void setExtAddress(const Q3CString & s) |
44 | { extAddress_ = s; assembled_ = false; } | 46 | { extAddress_ = s; assembled_ = false; } |
45 | 47 | ||
46 | void setStreet(const QCString & s) | 48 | void setStreet(const Q3CString & s) |
47 | { street_ = s; assembled_ = false; } | 49 | { street_ = s; assembled_ = false; } |
48 | 50 | ||
49 | void setLocality(const QCString & s) | 51 | void setLocality(const Q3CString & s) |
50 | { locality_ = s; assembled_ = false; } | 52 | { locality_ = s; assembled_ = false; } |
51 | 53 | ||
52 | void setRegion(const QCString & s) | 54 | void setRegion(const Q3CString & s) |
53 | { region_ = s; assembled_ = false; } | 55 | { region_ = s; assembled_ = false; } |
54 | 56 | ||
55 | void setPostCode(const QCString & s) | 57 | void setPostCode(const Q3CString & s) |
56 | { postCode_ = s; assembled_ = false; } | 58 | { postCode_ = s; assembled_ = false; } |
57 | 59 | ||
58 | void setCountryName(const QCString & s) | 60 | void setCountryName(const Q3CString & s) |
59 | { countryName_ = s; assembled_ = false; } | 61 | { countryName_ = s; assembled_ = false; } |
60 | 62 | ||
61 | QCString poBox() { parse(); return poBox_;} | 63 | Q3CString poBox() { parse(); return poBox_;} |
62 | QCString extAddress() { parse(); return extAddress_;} | 64 | Q3CString extAddress() { parse(); return extAddress_;} |
63 | QCString street() { parse(); return street_;} | 65 | Q3CString street() { parse(); return street_;} |
64 | QCString locality() { parse(); return locality_;} | 66 | Q3CString locality() { parse(); return locality_;} |
65 | QCString region() { parse(); return region_;} | 67 | Q3CString region() { parse(); return region_;} |
66 | QCString postCode() { parse(); return postCode_;} | 68 | Q3CString postCode() { parse(); return postCode_;} |
67 | QCString countryName() { parse(); return countryName_;} | 69 | Q3CString countryName() { parse(); return countryName_;} |
68 | 70 | ||
69 | private: | 71 | private: |
70 | 72 | ||
71 | QCString poBox_; | 73 | Q3CString poBox_; |
72 | QCString extAddress_; | 74 | Q3CString extAddress_; |
73 | QCString street_; | 75 | Q3CString street_; |
74 | QCString locality_; | 76 | Q3CString locality_; |
75 | QCString region_; | 77 | Q3CString region_; |
76 | QCString postCode_; | 78 | Q3CString postCode_; |
77 | QCString countryName_; | 79 | Q3CString countryName_; |
78 | }; | 80 | }; |
79 | 81 | ||
80 | } | 82 | } |
81 | 83 | ||
82 | #endif | 84 | #endif |
83 | 85 | ||
diff --git a/kabc/vcard/include/VCardAgentParam.h b/kabc/vcard/include/VCardAgentParam.h index 72a05db..5733540 100644 --- a/kabc/vcard/include/VCardAgentParam.h +++ b/kabc/vcard/include/VCardAgentParam.h | |||
@@ -1,60 +1,60 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef AGENTPARAM_H | 24 | #ifndef AGENTPARAM_H |
25 | #define AGENTPARAM_H | 25 | #define AGENTPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | #include <VCardURIValue.h> | 30 | #include <VCardURIValue.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class AgentParam : public Param | 35 | class AgentParam : public Param |
36 | { | 36 | { |
37 | 37 | ||
38 | #include "AgentParam-generated.h" | 38 | #include "AgentParam-generated.h" |
39 | 39 | ||
40 | bool refer() | 40 | bool refer() |
41 | { parse(); return refer_; } | 41 | { parse(); return refer_; } |
42 | 42 | ||
43 | URIValue uri() | 43 | URIValue uri() |
44 | { parse(); return uri_; } | 44 | { parse(); return uri_; } |
45 | 45 | ||
46 | void setRefer(bool b) | 46 | void setRefer(bool b) |
47 | { refer_ = b; assembled_ = false; } | 47 | { refer_ = b; assembled_ = false; } |
48 | 48 | ||
49 | void setURI(const QCString & s) | 49 | void setURI(const Q3CString & s) |
50 | { uri_ = s; assembled_ = false; } | 50 | { uri_ = s; assembled_ = false; } |
51 | 51 | ||
52 | private: | 52 | private: |
53 | 53 | ||
54 | bool refer_; | 54 | bool refer_; |
55 | URIValueuri_; | 55 | URIValueuri_; |
56 | }; | 56 | }; |
57 | 57 | ||
58 | } | 58 | } |
59 | 59 | ||
60 | #endif | 60 | #endif |
diff --git a/kabc/vcard/include/VCardAgentValue.h b/kabc/vcard/include/VCardAgentValue.h index f655836..b0d883b 100644 --- a/kabc/vcard/include/VCardAgentValue.h +++ b/kabc/vcard/include/VCardAgentValue.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef AGENTVALUE_H | 24 | #ifndef AGENTVALUE_H |
25 | #define AGENTVALUE_H | 25 | #define AGENTVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class AgentValue : public Value | 34 | class AgentValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "AgentValue-generated.h" | 37 | #include "AgentValue-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardClassValue.h b/kabc/vcard/include/VCardClassValue.h index ff133c2..c450169 100644 --- a/kabc/vcard/include/VCardClassValue.h +++ b/kabc/vcard/include/VCardClassValue.h | |||
@@ -1,56 +1,56 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef CLASSVALUE_H | 24 | #ifndef CLASSVALUE_H |
25 | #define CLASSVALUE_H | 25 | #define CLASSVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | #include <kdebug.h> | 31 | #include <kdebug.h> |
32 | 32 | ||
33 | namespace VCARD | 33 | namespace VCARD |
34 | { | 34 | { |
35 | 35 | ||
36 | class ClassValue : public Value | 36 | class ClassValue : public Value |
37 | { | 37 | { |
38 | 38 | ||
39 | #include "ClassValue-generated.h" | 39 | #include "ClassValue-generated.h" |
40 | 40 | ||
41 | enum ClassType { | 41 | enum ClassType { |
42 | Public, Private, Confidential, Other | 42 | Public, Private, Confidential, Other |
43 | }; | 43 | }; |
44 | 44 | ||
45 | ClassValue *clone(); | 45 | ClassValue *clone(); |
46 | 46 | ||
47 | void setType( int type ) { classType_ = type; assembled_ = false; parsed_ = true; } | 47 | void setType( int type ) { classType_ = type; assembled_ = false; parsed_ = true; } |
48 | int type() { parse(); return classType_; } | 48 | int type() { parse(); return classType_; } |
49 | 49 | ||
50 | private: | 50 | private: |
51 | int classType_; | 51 | int classType_; |
52 | }; | 52 | }; |
53 | 53 | ||
54 | } | 54 | } |
55 | 55 | ||
56 | #endif | 56 | #endif |
diff --git a/kabc/vcard/include/VCardContentLine.h b/kabc/vcard/include/VCardContentLine.h index 1c5f5be..c3c5253 100644 --- a/kabc/vcard/include/VCardContentLine.h +++ b/kabc/vcard/include/VCardContentLine.h | |||
@@ -1,77 +1,79 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef CONTENTLINE_H | 24 | #ifndef CONTENTLINE_H |
25 | #define CONTENTLINE_H | 25 | #define CONTENTLINE_H |
26 | 26 | ||
27 | #include <qptrlist.h> | 27 | #include <q3ptrlist.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3CString> | ||
28 | 30 | ||
29 | #include "VCardEnum.h" | 31 | #include "VCardEnum.h" |
30 | #include "VCardEntity.h" | 32 | #include "VCardEntity.h" |
31 | #include "VCardParam.h" | 33 | #include "VCardParam.h" |
32 | #include "VCardValue.h" | 34 | #include "VCardValue.h" |
33 | 35 | ||
34 | namespace VCARD | 36 | namespace VCARD |
35 | { | 37 | { |
36 | 38 | ||
37 | class ContentLine : public Entity | 39 | class ContentLine : public Entity |
38 | { | 40 | { |
39 | 41 | ||
40 | #include "ContentLine-generated.h" | 42 | #include "ContentLine-generated.h" |
41 | 43 | ||
42 | QCString group() { parse(); return group_;} | 44 | Q3CString group() { parse(); return group_;} |
43 | QCString name() { parse(); return name_;} | 45 | Q3CString name() { parse(); return name_;} |
44 | Value * value() { parse(); return value_;} | 46 | Value * value() { parse(); return value_;} |
45 | ParamList paramList() { parse(); return paramList_;} | 47 | ParamList paramList() { parse(); return paramList_;} |
46 | ParamType paramType() { parse(); return paramType_;} | 48 | ParamType paramType() { parse(); return paramType_;} |
47 | ValueType valueType() { parse(); return valueType_;} | 49 | ValueType valueType() { parse(); return valueType_;} |
48 | EntityType entityType() { parse(); return entityType_;} | 50 | EntityType entityType() { parse(); return entityType_;} |
49 | 51 | ||
50 | void setGroup (const QCString & s) | 52 | void setGroup (const Q3CString & s) |
51 | { group_ = s; assembled_ = false; } | 53 | { group_ = s; assembled_ = false; } |
52 | 54 | ||
53 | void setName (const QCString & s) | 55 | void setName (const Q3CString & s) |
54 | { name_ = s; assembled_ = false; } | 56 | { name_ = s; assembled_ = false; } |
55 | 57 | ||
56 | void setValue (Value *s) | 58 | void setValue (Value *s) |
57 | { value_ = s; assembled_ = false; } | 59 | { value_ = s; assembled_ = false; } |
58 | 60 | ||
59 | void setParamList(const ParamList & l) | 61 | void setParamList(const ParamList & l) |
60 | { paramList_ = l; assembled_ = false; } | 62 | { paramList_ = l; assembled_ = false; } |
61 | 63 | ||
62 | void clear (); | 64 | void clear (); |
63 | 65 | ||
64 | private: | 66 | private: |
65 | 67 | ||
66 | QCString group_; | 68 | Q3CString group_; |
67 | QCString name_; | 69 | Q3CString name_; |
68 | QPtrList<Param> paramList_; | 70 | Q3PtrList<Param> paramList_; |
69 | Value * value_; | 71 | Value * value_; |
70 | 72 | ||
71 | ParamType paramType_; | 73 | ParamType paramType_; |
72 | ValueType valueType_; | 74 | ValueType valueType_; |
73 | EntityType entityType_; | 75 | EntityType entityType_; |
74 | }; | 76 | }; |
75 | } | 77 | } |
76 | 78 | ||
77 | #endif | 79 | #endif |
diff --git a/kabc/vcard/include/VCardDateParam.h b/kabc/vcard/include/VCardDateParam.h index 21ac1f1..959b75b 100644 --- a/kabc/vcard/include/VCardDateParam.h +++ b/kabc/vcard/include/VCardDateParam.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef DATEPARAM_H | 24 | #ifndef DATEPARAM_H |
25 | #define DATEPARAM_H | 25 | #define DATEPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class DateParam : public Param | 34 | class DateParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "DateParam-generated.h" | 37 | #include "DateParam-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardDateValue.h b/kabc/vcard/include/VCardDateValue.h index c248966..fc216c0 100644 --- a/kabc/vcard/include/VCardDateValue.h +++ b/kabc/vcard/include/VCardDateValue.h | |||
@@ -1,99 +1,99 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef DATEVALUE_H | 24 | #ifndef DATEVALUE_H |
25 | #define DATEVALUE_H | 25 | #define DATEVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qdatetime.h> | 28 | #include <qdatetime.h> |
29 | 29 | ||
30 | #include <VCardValue.h> | 30 | #include <VCardValue.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class DateValue : public Value | 35 | class DateValue : public Value |
36 | { | 36 | { |
37 | #include "DateValue-generated.h" | 37 | #include "DateValue-generated.h" |
38 | 38 | ||
39 | DateValue( | 39 | DateValue( |
40 | unsigned intyear, | 40 | unsigned intyear, |
41 | unsigned intmonth, | 41 | unsigned intmonth, |
42 | unsigned intday, | 42 | unsigned intday, |
43 | unsigned inthour = 0, | 43 | unsigned inthour = 0, |
44 | unsigned intminute = 0, | 44 | unsigned intminute = 0, |
45 | unsigned intsecond = 0, | 45 | unsigned intsecond = 0, |
46 | double secFrac = 0, | 46 | double secFrac = 0, |
47 | bool zonePositive = true, | 47 | bool zonePositive = true, |
48 | unsigned intzoneHour = 0, | 48 | unsigned intzoneHour = 0, |
49 | unsigned intzoneMinute = 0); | 49 | unsigned intzoneMinute = 0); |
50 | 50 | ||
51 | DateValue(const QDate &); | 51 | DateValue(const QDate &); |
52 | DateValue(const QDateTime &); | 52 | DateValue(const QDateTime &); |
53 | 53 | ||
54 | DateValue *clone(); | 54 | DateValue *clone(); |
55 | 55 | ||
56 | bool hasTime(); | 56 | bool hasTime(); |
57 | 57 | ||
58 | unsigned intyear(); | 58 | unsigned intyear(); |
59 | unsigned intmonth(); | 59 | unsigned intmonth(); |
60 | unsigned intday(); | 60 | unsigned intday(); |
61 | unsigned inthour(); | 61 | unsigned inthour(); |
62 | unsigned intminute(); | 62 | unsigned intminute(); |
63 | unsigned intsecond(); | 63 | unsigned intsecond(); |
64 | double secondFraction(); | 64 | double secondFraction(); |
65 | bool zonePositive(); | 65 | bool zonePositive(); |
66 | unsigned intzoneHour(); | 66 | unsigned intzoneHour(); |
67 | unsigned intzoneMinute(); | 67 | unsigned intzoneMinute(); |
68 | 68 | ||
69 | void setYear (unsigned int); | 69 | void setYear (unsigned int); |
70 | void setMonth (unsigned int); | 70 | void setMonth (unsigned int); |
71 | void setDay (unsigned int); | 71 | void setDay (unsigned int); |
72 | void setHour (unsigned int); | 72 | void setHour (unsigned int); |
73 | void setMinute (unsigned int); | 73 | void setMinute (unsigned int); |
74 | void setSecond (unsigned int); | 74 | void setSecond (unsigned int); |
75 | void setSecondFraction(double); | 75 | void setSecondFraction(double); |
76 | void setZonePositive(bool); | 76 | void setZonePositive(bool); |
77 | void setZoneHour (unsigned int); | 77 | void setZoneHour (unsigned int); |
78 | void setZoneMinute (unsigned int); | 78 | void setZoneMinute (unsigned int); |
79 | 79 | ||
80 | QDate qdate(); | 80 | QDate qdate(); |
81 | QTime qtime(); | 81 | QTime qtime(); |
82 | QDateTime qdt(); | 82 | QDateTime qdt(); |
83 | 83 | ||
84 | private: | 84 | private: |
85 | 85 | ||
86 | unsigned intyear_, month_, day_, | 86 | unsigned intyear_, month_, day_, |
87 | hour_, minute_, second_, | 87 | hour_, minute_, second_, |
88 | zoneHour_, zoneMinute_; | 88 | zoneHour_, zoneMinute_; |
89 | 89 | ||
90 | double secFrac_; | 90 | double secFrac_; |
91 | 91 | ||
92 | bool zonePositive_; | 92 | bool zonePositive_; |
93 | 93 | ||
94 | bool hasTime_; | 94 | bool hasTime_; |
95 | }; | 95 | }; |
96 | 96 | ||
97 | } | 97 | } |
98 | 98 | ||
99 | #endif | 99 | #endif |
diff --git a/kabc/vcard/include/VCardDefines.h b/kabc/vcard/include/VCardDefines.h index 557410f..5d4f2f4 100644 --- a/kabc/vcard/include/VCardDefines.h +++ b/kabc/vcard/include/VCardDefines.h | |||
@@ -1,53 +1,53 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1998 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1998 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef VCARD_DEFINES_H | 24 | #ifndef VCARD_DEFINES_H |
25 | #define VCARD_DEFINES_H | 25 | #define VCARD_DEFINES_H |
26 | 26 | ||
27 | #include <kdebug.h> | 27 | #include <kdebug.h> |
28 | 28 | ||
29 | #ifdef VCARD_DEBUG | 29 | #ifdef VCARD_DEBUG |
30 | //US #define vDebug(a) kdDebug(5710) << a << endl; | 30 | //US #define vDebug(a) kdDebug(5710) << a << endl; |
31 | #define vDebug(a) qDebug(a); | 31 | #define vDebug(a) qDebug(a); |
32 | #else | 32 | #else |
33 | #define vDebug(a) | 33 | #define vDebug(a) |
34 | #endif | 34 | #endif |
35 | 35 | ||
36 | #if 0 | 36 | #if 0 |
37 | #ifndef NDEBUG | 37 | #ifndef NDEBUG |
38 | #include <qcstring.h> | 38 | #include <q3cstring.h> |
39 | #include <iostream> | 39 | #include <iostream> |
40 | #ifdef __GNUG__ | 40 | #ifdef __GNUG__ |
41 | # define vDebug(a) cerr << className() << ":" << __FUNCTION__ << " (" \ | 41 | # define vDebug(a) cerr << className() << ":" << __FUNCTION__ << " (" \ |
42 | << __LINE__ << "): " << QCString((a)).data() << endl; | 42 | << __LINE__ << "): " << Q3CString((a)).data() << endl; |
43 | #else | 43 | #else |
44 | # define vDebug(a) cerr << className() << ": " \ | 44 | # define vDebug(a) cerr << className() << ": " \ |
45 | << QCString((a)).data() << endl; | 45 | << Q3CString((a)).data() << endl; |
46 | #endif | 46 | #endif |
47 | #else | 47 | #else |
48 | #define vDebug(a) | 48 | #define vDebug(a) |
49 | #endif | 49 | #endif |
50 | #endif | 50 | #endif |
51 | 51 | ||
52 | #endif // Included this file | 52 | #endif // Included this file |
53 | 53 | ||
diff --git a/kabc/vcard/include/VCardEmailParam.h b/kabc/vcard/include/VCardEmailParam.h index 98d1b30..ff07324 100644 --- a/kabc/vcard/include/VCardEmailParam.h +++ b/kabc/vcard/include/VCardEmailParam.h | |||
@@ -1,56 +1,56 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef EMAILPARAM_H | 24 | #ifndef EMAILPARAM_H |
25 | #define EMAILPARAM_H | 25 | #define EMAILPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class EmailParam : public Param | 34 | class EmailParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "EmailParam-generated.h" | 37 | #include "EmailParam-generated.h" |
38 | 38 | ||
39 | QCString emailType() { parse(); return emailType_;} | 39 | Q3CString emailType() { parse(); return emailType_;} |
40 | bool pref() { parse(); return pref_; } | 40 | bool pref() { parse(); return pref_; } |
41 | 41 | ||
42 | void setEmailType(const QCString & s) | 42 | void setEmailType(const Q3CString & s) |
43 | { emailType_ = s; assembled_ = false; } | 43 | { emailType_ = s; assembled_ = false; } |
44 | 44 | ||
45 | void setPref(bool b) | 45 | void setPref(bool b) |
46 | { pref_ = b; assembled_ = false; } | 46 | { pref_ = b; assembled_ = false; } |
47 | 47 | ||
48 | private: | 48 | private: |
49 | 49 | ||
50 | QCStringemailType_; | 50 | Q3CStringemailType_; |
51 | bool pref_; | 51 | bool pref_; |
52 | }; | 52 | }; |
53 | 53 | ||
54 | } | 54 | } |
55 | 55 | ||
56 | #endif | 56 | #endif |
diff --git a/kabc/vcard/include/VCardEntity.h b/kabc/vcard/include/VCardEntity.h index 3c945b5..1a3d20f 100644 --- a/kabc/vcard/include/VCardEntity.h +++ b/kabc/vcard/include/VCardEntity.h | |||
@@ -1,67 +1,67 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef ENTITY_H | 24 | #ifndef ENTITY_H |
25 | #define ENTITY_H | 25 | #define ENTITY_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | namespace VCARD | 29 | namespace VCARD |
30 | { | 30 | { |
31 | 31 | ||
32 | class Entity | 32 | class Entity |
33 | { | 33 | { |
34 | public: | 34 | public: |
35 | 35 | ||
36 | Entity(); | 36 | Entity(); |
37 | Entity(const Entity & e); | 37 | Entity(const Entity & e); |
38 | Entity(const QCString & s); | 38 | Entity(const Q3CString & s); |
39 | 39 | ||
40 | virtual Entity & operator = (const Entity & e); | 40 | virtual Entity & operator = (const Entity & e); |
41 | virtual Entity & operator = (const QCString & s); | 41 | virtual Entity & operator = (const Q3CString & s); |
42 | 42 | ||
43 | virtual bool operator == (Entity & e); | 43 | virtual bool operator == (Entity & e); |
44 | virtual bool operator != (Entity & e); | 44 | virtual bool operator != (Entity & e); |
45 | virtual bool operator == (const QCString & s); | 45 | virtual bool operator == (const Q3CString & s); |
46 | virtual bool operator != (const QCString & s); | 46 | virtual bool operator != (const Q3CString & s); |
47 | 47 | ||
48 | virtual ~Entity(); | 48 | virtual ~Entity(); |
49 | 49 | ||
50 | QCString asString(); | 50 | Q3CString asString(); |
51 | 51 | ||
52 | virtual void parse(); | 52 | virtual void parse(); |
53 | virtual void assemble(); | 53 | virtual void assemble(); |
54 | 54 | ||
55 | virtual void _parse() = 0; | 55 | virtual void _parse() = 0; |
56 | virtual void _assemble() = 0; | 56 | virtual void _assemble() = 0; |
57 | 57 | ||
58 | protected: | 58 | protected: |
59 | 59 | ||
60 | QCString strRep_; | 60 | Q3CString strRep_; |
61 | bool parsed_; | 61 | bool parsed_; |
62 | bool assembled_; | 62 | bool assembled_; |
63 | }; | 63 | }; |
64 | 64 | ||
65 | } | 65 | } |
66 | 66 | ||
67 | #endif | 67 | #endif |
diff --git a/kabc/vcard/include/VCardEnum.h b/kabc/vcard/include/VCardEnum.h index b4e4094..0c35e5e 100644 --- a/kabc/vcard/include/VCardEnum.h +++ b/kabc/vcard/include/VCardEnum.h | |||
@@ -1,120 +1,120 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef ENUM_H | 24 | #ifndef ENUM_H |
25 | #define ENUM_H | 25 | #define ENUM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | namespace VCARD | 29 | namespace VCARD |
30 | { | 30 | { |
31 | 31 | ||
32 | extern const QCString paramNames []; | 32 | extern const Q3CString paramNames []; |
33 | 33 | ||
34 | enum EntityType { | 34 | enum EntityType { |
35 | EntityName, | 35 | EntityName, |
36 | EntityProfile, | 36 | EntityProfile, |
37 | EntitySource, | 37 | EntitySource, |
38 | EntityFullName, | 38 | EntityFullName, |
39 | EntityN, | 39 | EntityN, |
40 | EntityNickname, | 40 | EntityNickname, |
41 | EntityPhoto, | 41 | EntityPhoto, |
42 | EntityBirthday, | 42 | EntityBirthday, |
43 | EntityAddress, | 43 | EntityAddress, |
44 | EntityLabel, | 44 | EntityLabel, |
45 | EntityTelephone, | 45 | EntityTelephone, |
46 | EntityEmail, | 46 | EntityEmail, |
47 | EntityMailer, | 47 | EntityMailer, |
48 | EntityTimeZone, | 48 | EntityTimeZone, |
49 | EntityGeo, | 49 | EntityGeo, |
50 | EntityTitle, | 50 | EntityTitle, |
51 | EntityRole, | 51 | EntityRole, |
52 | EntityLogo, | 52 | EntityLogo, |
53 | EntityAgent, | 53 | EntityAgent, |
54 | EntityOrganisation, | 54 | EntityOrganisation, |
55 | EntityCategories, | 55 | EntityCategories, |
56 | EntityNote, | 56 | EntityNote, |
57 | EntityProductID, | 57 | EntityProductID, |
58 | EntityRevision, | 58 | EntityRevision, |
59 | EntitySortString, | 59 | EntitySortString, |
60 | EntitySound, | 60 | EntitySound, |
61 | EntityUID, | 61 | EntityUID, |
62 | EntityURL, | 62 | EntityURL, |
63 | EntityVersion, | 63 | EntityVersion, |
64 | EntityClass, | 64 | EntityClass, |
65 | EntityKey, | 65 | EntityKey, |
66 | EntityExtension, | 66 | EntityExtension, |
67 | EntityUnknown | 67 | EntityUnknown |
68 | }; | 68 | }; |
69 | 69 | ||
70 | enum ValueType { | 70 | enum ValueType { |
71 | ValueSound, | 71 | ValueSound, |
72 | ValueAgent, | 72 | ValueAgent, |
73 | ValueAddress, | 73 | ValueAddress, |
74 | ValueTel, | 74 | ValueTel, |
75 | ValueTextBin, | 75 | ValueTextBin, |
76 | ValueOrg, | 76 | ValueOrg, |
77 | ValueN, | 77 | ValueN, |
78 | ValueUTC, | 78 | ValueUTC, |
79 | ValueURI, | 79 | ValueURI, |
80 | ValueClass, | 80 | ValueClass, |
81 | ValueFloat, | 81 | ValueFloat, |
82 | ValueImage, | 82 | ValueImage, |
83 | ValueDate, | 83 | ValueDate, |
84 | ValueTextList, | 84 | ValueTextList, |
85 | ValueText, | 85 | ValueText, |
86 | ValueGeo, | 86 | ValueGeo, |
87 | ValueUnknown | 87 | ValueUnknown |
88 | }; | 88 | }; |
89 | 89 | ||
90 | enum ParamType { | 90 | enum ParamType { |
91 | ParamUnknown, | 91 | ParamUnknown, |
92 | ParamNone, | 92 | ParamNone, |
93 | ParamSource, | 93 | ParamSource, |
94 | ParamText, | 94 | ParamText, |
95 | ParamImage, | 95 | ParamImage, |
96 | ParamDate, | 96 | ParamDate, |
97 | ParamAddrText, | 97 | ParamAddrText, |
98 | ParamTel, | 98 | ParamTel, |
99 | ParamEmail, | 99 | ParamEmail, |
100 | ParamMailer, | 100 | ParamMailer, |
101 | ParamAgent, | 101 | ParamAgent, |
102 | ParamTextBin, | 102 | ParamTextBin, |
103 | ParamTextNS, | 103 | ParamTextNS, |
104 | ParamSound | 104 | ParamSound |
105 | }; | 105 | }; |
106 | 106 | ||
107 | extern const ParamType paramTypesTable[]; | 107 | extern const ParamType paramTypesTable[]; |
108 | 108 | ||
109 | ParamType EntityTypeToParamType(EntityType); | 109 | ParamType EntityTypeToParamType(EntityType); |
110 | ValueType EntityTypeToValueType(EntityType); | 110 | ValueType EntityTypeToValueType(EntityType); |
111 | QCString EntityTypeToParamName(EntityType); | 111 | Q3CString EntityTypeToParamName(EntityType); |
112 | EntityType EntityNameToEntityType(const QCString &); | 112 | EntityType EntityNameToEntityType(const Q3CString &); |
113 | 113 | ||
114 | char * encodeBase64(const char *, unsigned long, unsigned long &); | 114 | char * encodeBase64(const char *, unsigned long, unsigned long &); |
115 | char * decodeBase64(const char *, unsigned long, unsigned long &); | 115 | char * decodeBase64(const char *, unsigned long, unsigned long &); |
116 | 116 | ||
117 | } | 117 | } |
118 | 118 | ||
119 | #endif | 119 | #endif |
120 | 120 | ||
diff --git a/kabc/vcard/include/VCardFloatValue.h b/kabc/vcard/include/VCardFloatValue.h index 69fdc22..cac7a91 100644 --- a/kabc/vcard/include/VCardFloatValue.h +++ b/kabc/vcard/include/VCardFloatValue.h | |||
@@ -1,51 +1,51 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef FLOATVALUE_H | 24 | #ifndef FLOATVALUE_H |
25 | #define FLOATVALUE_H | 25 | #define FLOATVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class FloatValue : public Value | 34 | class FloatValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "FloatValue-generated.h" | 37 | #include "FloatValue-generated.h" |
38 | 38 | ||
39 | FloatValue(float); | 39 | FloatValue(float); |
40 | 40 | ||
41 | float value(); | 41 | float value(); |
42 | void setValue(float); | 42 | void setValue(float); |
43 | 43 | ||
44 | private: | 44 | private: |
45 | 45 | ||
46 | float value_; | 46 | float value_; |
47 | }; | 47 | }; |
48 | 48 | ||
49 | } | 49 | } |
50 | 50 | ||
51 | #endif | 51 | #endif |
diff --git a/kabc/vcard/include/VCardImageParam.h b/kabc/vcard/include/VCardImageParam.h index ce99ccc..2785331 100644 --- a/kabc/vcard/include/VCardImageParam.h +++ b/kabc/vcard/include/VCardImageParam.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef IMGPARAM_H | 24 | #ifndef IMGPARAM_H |
25 | #define IMGPARAM_H | 25 | #define IMGPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class ImageParam : public Param | 34 | class ImageParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "ImageParam-generated.h" | 37 | #include "ImageParam-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardImageValue.h b/kabc/vcard/include/VCardImageValue.h index 6ce0371..3b64731 100644 --- a/kabc/vcard/include/VCardImageValue.h +++ b/kabc/vcard/include/VCardImageValue.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef IMAGEVALUE_H | 24 | #ifndef IMAGEVALUE_H |
25 | #define IMAGEVALUE_H | 25 | #define IMAGEVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class ImageValue : public Value | 34 | class ImageValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "ImageValue-generated.h" | 37 | #include "ImageValue-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardLangValue.h b/kabc/vcard/include/VCardLangValue.h index 991ceed..319de76 100644 --- a/kabc/vcard/include/VCardLangValue.h +++ b/kabc/vcard/include/VCardLangValue.h | |||
@@ -1,51 +1,51 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef LANGVALUE_H | 24 | #ifndef LANGVALUE_H |
25 | #define LANGVALUE_H | 25 | #define LANGVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qstrlist.h> | 28 | #include <q3strlist.h> |
29 | 29 | ||
30 | #include <VCardValue.h> | 30 | #include <VCardValue.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class LangValue : public Value | 35 | class LangValue : public Value |
36 | { | 36 | { |
37 | #include "LangValue-generated.h" | 37 | #include "LangValue-generated.h" |
38 | 38 | ||
39 | QCString primary(); | 39 | Q3CString primary(); |
40 | QStrList subtags(); | 40 | Q3StrList subtags(); |
41 | 41 | ||
42 | void setPrimary(const QCString &); | 42 | void setPrimary(const Q3CString &); |
43 | void setSubTags(const QStrList &); | 43 | void setSubTags(const Q3StrList &); |
44 | 44 | ||
45 | QCString primary_; | 45 | Q3CString primary_; |
46 | QStrList subtags_; | 46 | Q3StrList subtags_; |
47 | }; | 47 | }; |
48 | 48 | ||
49 | } | 49 | } |
50 | 50 | ||
51 | #endif | 51 | #endif |
diff --git a/kabc/vcard/include/VCardNValue.h b/kabc/vcard/include/VCardNValue.h index 306821b..ffc5355 100644 --- a/kabc/vcard/include/VCardNValue.h +++ b/kabc/vcard/include/VCardNValue.h | |||
@@ -1,56 +1,58 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef NVALUE_H | 24 | #ifndef NVALUE_H |
25 | #define NVALUE_H | 25 | #define NVALUE_H |
26 | 26 | ||
27 | #include <VCardValue.h> | 27 | #include <VCardValue.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3CString> | ||
28 | 30 | ||
29 | namespace VCARD | 31 | namespace VCARD |
30 | { | 32 | { |
31 | 33 | ||
32 | class NValue : public Value | 34 | class NValue : public Value |
33 | { | 35 | { |
34 | #include "NValue-generated.h" | 36 | #include "NValue-generated.h" |
35 | NValue *clone(); | 37 | NValue *clone(); |
36 | 38 | ||
37 | QCString family() { parse(); return family_;} | 39 | Q3CString family() { parse(); return family_;} |
38 | QCString given() { parse(); return given_;} | 40 | Q3CString given() { parse(); return given_;} |
39 | QCString middle() { parse(); return middle_;} | 41 | Q3CString middle() { parse(); return middle_;} |
40 | QCString prefix() { parse(); return prefix_;} | 42 | Q3CString prefix() { parse(); return prefix_;} |
41 | QCString suffix() { parse(); return suffix_;} | 43 | Q3CString suffix() { parse(); return suffix_;} |
42 | 44 | ||
43 | void setFamily (const QCString & s) { family_= s; assembled_ = false; } | 45 | void setFamily (const Q3CString & s) { family_= s; assembled_ = false; } |
44 | void setGiven (const QCString & s) { given_= s; assembled_ = false; } | 46 | void setGiven (const Q3CString & s) { given_= s; assembled_ = false; } |
45 | void setMiddle (const QCString & s) { middle_= s; assembled_ = false; } | 47 | void setMiddle (const Q3CString & s) { middle_= s; assembled_ = false; } |
46 | void setPrefix (const QCString & s) { prefix_= s; assembled_ = false; } | 48 | void setPrefix (const Q3CString & s) { prefix_= s; assembled_ = false; } |
47 | void setSuffix (const QCString & s) { suffix_= s; assembled_ = false; } | 49 | void setSuffix (const Q3CString & s) { suffix_= s; assembled_ = false; } |
48 | 50 | ||
49 | private: | 51 | private: |
50 | 52 | ||
51 | QCString family_, given_, middle_, prefix_, suffix_; | 53 | Q3CString family_, given_, middle_, prefix_, suffix_; |
52 | }; | 54 | }; |
53 | 55 | ||
54 | } | 56 | } |
55 | 57 | ||
56 | #endif | 58 | #endif |
diff --git a/kabc/vcard/include/VCardOrgValue.h b/kabc/vcard/include/VCardOrgValue.h index c4f3f25..2e5d32f 100644 --- a/kabc/vcard/include/VCardOrgValue.h +++ b/kabc/vcard/include/VCardOrgValue.h | |||
@@ -1,50 +1,50 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef ORGVALUE_H | 24 | #ifndef ORGVALUE_H |
25 | #define ORGVALUE_H | 25 | #define ORGVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qstrlist.h> | 28 | #include <q3strlist.h> |
29 | 29 | ||
30 | #include <VCardValue.h> | 30 | #include <VCardValue.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class OrgValue : public Value | 35 | class OrgValue : public Value |
36 | { | 36 | { |
37 | 37 | ||
38 | #include "OrgValue-generated.h" | 38 | #include "OrgValue-generated.h" |
39 | 39 | ||
40 | unsigned int numValues(); | 40 | unsigned int numValues(); |
41 | QCString value(unsigned int); | 41 | Q3CString value(unsigned int); |
42 | 42 | ||
43 | private: | 43 | private: |
44 | 44 | ||
45 | QStrList valueList_; | 45 | Q3StrList valueList_; |
46 | }; | 46 | }; |
47 | 47 | ||
48 | } | 48 | } |
49 | 49 | ||
50 | #endif | 50 | #endif |
diff --git a/kabc/vcard/include/VCardParam.h b/kabc/vcard/include/VCardParam.h index b61ce5c..b83fde1 100644 --- a/kabc/vcard/include/VCardParam.h +++ b/kabc/vcard/include/VCardParam.h | |||
@@ -1,59 +1,59 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef PARAM_H | 24 | #ifndef PARAM_H |
25 | #define PARAM_H | 25 | #define PARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | #include <qptrlist.h> | 28 | #include <q3ptrlist.h> |
29 | 29 | ||
30 | #include <VCardEntity.h> | 30 | #include <VCardEntity.h> |
31 | 31 | ||
32 | namespace VCARD | 32 | namespace VCARD |
33 | { | 33 | { |
34 | 34 | ||
35 | class Param : public Entity | 35 | class Param : public Entity |
36 | { | 36 | { |
37 | 37 | ||
38 | #include "Param-generated.h" | 38 | #include "Param-generated.h" |
39 | 39 | ||
40 | Param(const QCString &name, const QCString &value); | 40 | Param(const Q3CString &name, const Q3CString &value); |
41 | 41 | ||
42 | void setName(const QCString &); | 42 | void setName(const Q3CString &); |
43 | void setValue(const QCString &); | 43 | void setValue(const Q3CString &); |
44 | 44 | ||
45 | QCString name(); | 45 | Q3CString name(); |
46 | QCString value(); | 46 | Q3CString value(); |
47 | 47 | ||
48 | private: | 48 | private: |
49 | 49 | ||
50 | QCString name_; | 50 | Q3CString name_; |
51 | QCString value_; | 51 | Q3CString value_; |
52 | }; | 52 | }; |
53 | 53 | ||
54 | typedef QPtrList<Param> ParamList; | 54 | typedef Q3PtrList<Param> ParamList; |
55 | typedef QPtrListIterator<Param> ParamListIterator; | 55 | typedef Q3PtrListIterator<Param> ParamListIterator; |
56 | 56 | ||
57 | } | 57 | } |
58 | 58 | ||
59 | #endif | 59 | #endif |
diff --git a/kabc/vcard/include/VCardRToken.h b/kabc/vcard/include/VCardRToken.h index 2f95f1b..4a5adb2 100644 --- a/kabc/vcard/include/VCardRToken.h +++ b/kabc/vcard/include/VCardRToken.h | |||
@@ -1,38 +1,38 @@ | |||
1 | /* | 1 | /* |
2 | 2 | ||
3 | libvcard - vCard parsing library for vCard version 3.0 | 3 | libvcard - vCard parsing library for vCard version 3.0 |
4 | 4 | ||
5 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 5 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
6 | 6 | ||
7 | Permission is hereby granted, free of charge, to any person obtaining a copy | 7 | Permission is hereby granted, free of charge, to any person obtaining a copy |
8 | of this software and associated documentation files (the "Software"), to | 8 | of this software and associated documentation files (the "Software"), to |
9 | deal in the Software without restriction, including without limitation the | 9 | deal in the Software without restriction, including without limitation the |
10 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 10 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
11 | sell copies of the Software, and to permit persons to whom the Software is | 11 | sell copies of the Software, and to permit persons to whom the Software is |
12 | furnished to do so, subject to the following conditions: | 12 | furnished to do so, subject to the following conditions: |
13 | 13 | ||
14 | The above copyright notice and this permission notice shall be included in | 14 | The above copyright notice and this permission notice shall be included in |
15 | all copies or substantial portions of the Software. | 15 | all copies or substantial portions of the Software. |
16 | 16 | ||
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
20 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 20 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
21 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 21 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
23 | */ | 23 | */ |
24 | 24 | ||
25 | #ifndef RTOKEN_H | 25 | #ifndef RTOKEN_H |
26 | #define RTOKEN_H | 26 | #define RTOKEN_H |
27 | 27 | ||
28 | #include <qstrlist.h> | 28 | #include <q3strlist.h> |
29 | 29 | ||
30 | namespace VCARD | 30 | namespace VCARD |
31 | { | 31 | { |
32 | 32 | ||
33 | Q_UINT32 RTokenise(const char * str, const char * delim, QStrList & l); | 33 | Q_UINT32 RTokenise(const char * str, const char * delim, Q3StrList & l); |
34 | 34 | ||
35 | } | 35 | } |
36 | 36 | ||
37 | #endif | 37 | #endif |
38 | 38 | ||
diff --git a/kabc/vcard/include/VCardSoundValue.h b/kabc/vcard/include/VCardSoundValue.h index 994f55e..26f750b 100644 --- a/kabc/vcard/include/VCardSoundValue.h +++ b/kabc/vcard/include/VCardSoundValue.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef SOUNDVALUE_H | 24 | #ifndef SOUNDVALUE_H |
25 | #define SOUNDVALUE_H | 25 | #define SOUNDVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class SoundValue : public Value | 34 | class SoundValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "SoundValue-generated.h" | 37 | #include "SoundValue-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardSourceParam.h b/kabc/vcard/include/VCardSourceParam.h index 887ea20..5218864 100644 --- a/kabc/vcard/include/VCardSourceParam.h +++ b/kabc/vcard/include/VCardSourceParam.h | |||
@@ -1,58 +1,58 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef SOURCEPARAM_H | 24 | #ifndef SOURCEPARAM_H |
25 | #define SOURCEPARAM_H | 25 | #define SOURCEPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class SourceParam : public Param | 34 | class SourceParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "SourceParam-generated.h" | 37 | #include "SourceParam-generated.h" |
38 | 38 | ||
39 | enum SourceParamType { TypeUnknown, TypeValue, TypeContext, TypeX }; | 39 | enum SourceParamType { TypeUnknown, TypeValue, TypeContext, TypeX }; |
40 | 40 | ||
41 | SourceParamType type(){ parse(); return type_;} | 41 | SourceParamType type(){ parse(); return type_;} |
42 | QCString par() { parse(); return par_; } | 42 | Q3CString par() { parse(); return par_; } |
43 | QCString val() { parse(); return val_; } | 43 | Q3CString val() { parse(); return val_; } |
44 | 44 | ||
45 | void setType(SourceParamType t) { type_= t; assembled_ = false; } | 45 | void setType(SourceParamType t) { type_= t; assembled_ = false; } |
46 | void setPar(const QCString & s) { par_= s; assembled_ = false; } | 46 | void setPar(const Q3CString & s) { par_= s; assembled_ = false; } |
47 | void setVal(const QCString & s) { val_= s; assembled_ = false; } | 47 | void setVal(const Q3CString & s) { val_= s; assembled_ = false; } |
48 | 48 | ||
49 | private: | 49 | private: |
50 | 50 | ||
51 | SourceParamType type_; | 51 | SourceParamType type_; |
52 | // May be "VALUE = uri" or "CONTEXT = word" or "x-name = *SAFE-CHAR" | 52 | // May be "VALUE = uri" or "CONTEXT = word" or "x-name = *SAFE-CHAR" |
53 | QCString par_, val_; // Sub-parameter, value | 53 | Q3CString par_, val_; // Sub-parameter, value |
54 | }; | 54 | }; |
55 | 55 | ||
56 | } | 56 | } |
57 | 57 | ||
58 | #endif | 58 | #endif |
diff --git a/kabc/vcard/include/VCardTelParam.h b/kabc/vcard/include/VCardTelParam.h index 27d7dcc..0c45a3a 100644 --- a/kabc/vcard/include/VCardTelParam.h +++ b/kabc/vcard/include/VCardTelParam.h | |||
@@ -1,51 +1,53 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TELPARAM_H | 24 | #ifndef TELPARAM_H |
25 | #define TELPARAM_H | 25 | #define TELPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3PtrList> | ||
28 | 30 | ||
29 | #include <VCardParam.h> | 31 | #include <VCardParam.h> |
30 | 32 | ||
31 | namespace VCARD | 33 | namespace VCARD |
32 | { | 34 | { |
33 | 35 | ||
34 | class TelParam : public Param | 36 | class TelParam : public Param |
35 | { | 37 | { |
36 | #include "TelParam-generated.h" | 38 | #include "TelParam-generated.h" |
37 | 39 | ||
38 | enum TelType { | 40 | enum TelType { |
39 | TelHome, TelWork, TelPref, TelVoice, TelFex, TelMsg, TelCell, | 41 | TelHome, TelWork, TelPref, TelVoice, TelFex, TelMsg, TelCell, |
40 | TelPager, TelBBS, TelModem, TelCar, TelISDN, TelVideo, TelPCS, | 42 | TelPager, TelBBS, TelModem, TelCar, TelISDN, TelVideo, TelPCS, |
41 | TelIANA, TelX | 43 | TelIANA, TelX |
42 | }; | 44 | }; |
43 | 45 | ||
44 | private: | 46 | private: |
45 | 47 | ||
46 | QPtrList<TelType> types_; | 48 | Q3PtrList<TelType> types_; |
47 | }; | 49 | }; |
48 | 50 | ||
49 | } | 51 | } |
50 | 52 | ||
51 | #endif | 53 | #endif |
diff --git a/kabc/vcard/include/VCardTelValue.h b/kabc/vcard/include/VCardTelValue.h index 9cf5a98..a119e4a 100644 --- a/kabc/vcard/include/VCardTelValue.h +++ b/kabc/vcard/include/VCardTelValue.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TELVALUE_H | 24 | #ifndef TELVALUE_H |
25 | #define TELVALUE_H | 25 | #define TELVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class TelValue : public Value | 34 | class TelValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "TelValue-generated.h" | 37 | #include "TelValue-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardTextBinParam.h b/kabc/vcard/include/VCardTextBinParam.h index 31dec86..d186995 100644 --- a/kabc/vcard/include/VCardTextBinParam.h +++ b/kabc/vcard/include/VCardTextBinParam.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TEXTBINPARAM_H | 24 | #ifndef TEXTBINPARAM_H |
25 | #define TEXTBINPARAM_H | 25 | #define TEXTBINPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class TextBinParam : public Param | 34 | class TextBinParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "TextBinParam-generated.h" | 37 | #include "TextBinParam-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardTextBinValue.h b/kabc/vcard/include/VCardTextBinValue.h index 8d44fdf..3924f2a 100644 --- a/kabc/vcard/include/VCardTextBinValue.h +++ b/kabc/vcard/include/VCardTextBinValue.h | |||
@@ -1,67 +1,67 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TEXTBINVALUE_H | 24 | #ifndef TEXTBINVALUE_H |
25 | #define TEXTBINVALUE_H | 25 | #define TEXTBINVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class TextBinValue : public Value | 34 | class TextBinValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "TextBinValue-generated.h" | 37 | #include "TextBinValue-generated.h" |
38 | 38 | ||
39 | TextBinValue *clone(); | 39 | TextBinValue *clone(); |
40 | 40 | ||
41 | bool isBinary() { parse(); return mIsBinary_; } | 41 | bool isBinary() { parse(); return mIsBinary_; } |
42 | QByteArray data() { parse(); return mData_; } | 42 | QByteArray data() { parse(); return mData_; } |
43 | QString url() { parse(); return mUrl_; } | 43 | QString url() { parse(); return mUrl_; } |
44 | 44 | ||
45 | void setData( const QByteArray &data ) | 45 | void setData( const QByteArray &data ) |
46 | { | 46 | { |
47 | mData_ = data; | 47 | mData_ = data; |
48 | mIsBinary_ = true; | 48 | mIsBinary_ = true; |
49 | assembled_ = false; | 49 | assembled_ = false; |
50 | } | 50 | } |
51 | 51 | ||
52 | void setUrl( const QString &url ) | 52 | void setUrl( const QString &url ) |
53 | { | 53 | { |
54 | mUrl_ = url; | 54 | mUrl_ = url; |
55 | mIsBinary_ = false; | 55 | mIsBinary_ = false; |
56 | assembled_ = false; | 56 | assembled_ = false; |
57 | } | 57 | } |
58 | 58 | ||
59 | private: | 59 | private: |
60 | int mIsBinary_; | 60 | int mIsBinary_; |
61 | QByteArray mData_; | 61 | QByteArray mData_; |
62 | QString mUrl_; | 62 | QString mUrl_; |
63 | }; | 63 | }; |
64 | 64 | ||
65 | } | 65 | } |
66 | 66 | ||
67 | #endif | 67 | #endif |
diff --git a/kabc/vcard/include/VCardTextListValue.h b/kabc/vcard/include/VCardTextListValue.h index 8e47af5..ac42a29 100644 --- a/kabc/vcard/include/VCardTextListValue.h +++ b/kabc/vcard/include/VCardTextListValue.h | |||
@@ -1,51 +1,51 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TEXTLISTVALUE_H | 24 | #ifndef TEXTLISTVALUE_H |
25 | #define TEXTLISTVALUE_H | 25 | #define TEXTLISTVALUE_H |
26 | 26 | ||
27 | #include <qstrlist.h> | 27 | #include <q3strlist.h> |
28 | 28 | ||
29 | #include <qcstring.h> | 29 | #include <q3cstring.h> |
30 | 30 | ||
31 | #include <VCardValue.h> | 31 | #include <VCardValue.h> |
32 | 32 | ||
33 | namespace VCARD | 33 | namespace VCARD |
34 | { | 34 | { |
35 | 35 | ||
36 | class TextListValue : public Value | 36 | class TextListValue : public Value |
37 | { | 37 | { |
38 | 38 | ||
39 | #include "TextListValue-generated.h" | 39 | #include "TextListValue-generated.h" |
40 | 40 | ||
41 | unsigned int numValues(); | 41 | unsigned int numValues(); |
42 | QCString value(unsigned int); | 42 | Q3CString value(unsigned int); |
43 | 43 | ||
44 | private: | 44 | private: |
45 | 45 | ||
46 | QStrList valueList_; | 46 | Q3StrList valueList_; |
47 | }; | 47 | }; |
48 | 48 | ||
49 | } | 49 | } |
50 | 50 | ||
51 | #endif | 51 | #endif |
diff --git a/kabc/vcard/include/VCardTextParam.h b/kabc/vcard/include/VCardTextParam.h index 08b5f57..2503337 100644 --- a/kabc/vcard/include/VCardTextParam.h +++ b/kabc/vcard/include/VCardTextParam.h | |||
@@ -1,44 +1,44 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef TEXTPARAM_H | 24 | #ifndef TEXTPARAM_H |
25 | #define TEXTPARAM_H | 25 | #define TEXTPARAM_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardParam.h> | 29 | #include <VCardParam.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class TextParam : public Param | 34 | class TextParam : public Param |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "TextParam-generated.h" | 37 | #include "TextParam-generated.h" |
38 | 38 | ||
39 | private: | 39 | private: |
40 | }; | 40 | }; |
41 | 41 | ||
42 | } | 42 | } |
43 | 43 | ||
44 | #endif | 44 | #endif |
diff --git a/kabc/vcard/include/VCardURIValue.h b/kabc/vcard/include/VCardURIValue.h index 5fd7184..116e4c8 100644 --- a/kabc/vcard/include/VCardURIValue.h +++ b/kabc/vcard/include/VCardURIValue.h | |||
@@ -1,52 +1,54 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef URIVALUE_H | 24 | #ifndef URIVALUE_H |
25 | #define URIVALUE_H | 25 | #define URIVALUE_H |
26 | 26 | ||
27 | #include <VCardValue.h> | 27 | #include <VCardValue.h> |
28 | //Added by qt3to4: | ||
29 | #include <Q3CString> | ||
28 | 30 | ||
29 | namespace VCARD | 31 | namespace VCARD |
30 | { | 32 | { |
31 | 33 | ||
32 | class URIValue : public Value | 34 | class URIValue : public Value |
33 | { | 35 | { |
34 | #include "URIValue-generated.h" | 36 | #include "URIValue-generated.h" |
35 | 37 | ||
36 | URIValue(const QCString & scheme, const QCString & schemeSpecificPart); | 38 | URIValue(const Q3CString & scheme, const Q3CString & schemeSpecificPart); |
37 | 39 | ||
38 | QCString scheme(); | 40 | Q3CString scheme(); |
39 | QCString schemeSpecificPart(); | 41 | Q3CString schemeSpecificPart(); |
40 | 42 | ||
41 | void setScheme (const QCString &); | 43 | void setScheme (const Q3CString &); |
42 | void setSchemeSpecificPart(const QCString &); | 44 | void setSchemeSpecificPart(const Q3CString &); |
43 | 45 | ||
44 | private: | 46 | private: |
45 | 47 | ||
46 | QCString scheme_; | 48 | Q3CString scheme_; |
47 | QCString schemeSpecificPart_; | 49 | Q3CString schemeSpecificPart_; |
48 | }; | 50 | }; |
49 | 51 | ||
50 | } | 52 | } |
51 | 53 | ||
52 | #endif | 54 | #endif |
diff --git a/kabc/vcard/include/VCardUTCValue.h b/kabc/vcard/include/VCardUTCValue.h index ff695e0..eb69829 100644 --- a/kabc/vcard/include/VCardUTCValue.h +++ b/kabc/vcard/include/VCardUTCValue.h | |||
@@ -1,58 +1,58 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef UTCVALUE_H | 24 | #ifndef UTCVALUE_H |
25 | #define UTCVALUE_H | 25 | #define UTCVALUE_H |
26 | 26 | ||
27 | #include <qcstring.h> | 27 | #include <q3cstring.h> |
28 | 28 | ||
29 | #include <VCardValue.h> | 29 | #include <VCardValue.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class UTCValue : public Value | 34 | class UTCValue : public Value |
35 | { | 35 | { |
36 | 36 | ||
37 | #include "UTCValue-generated.h" | 37 | #include "UTCValue-generated.h" |
38 | 38 | ||
39 | UTCValue *clone(); | 39 | UTCValue *clone(); |
40 | 40 | ||
41 | void setPositive( int p ) { positive_ = p; assembled_ = false; } | 41 | void setPositive( int p ) { positive_ = p; assembled_ = false; } |
42 | void setHour( int h ) { hour_ = h; assembled_ = false; } | 42 | void setHour( int h ) { hour_ = h; assembled_ = false; } |
43 | void setMinute( int m ) { minute_ = m; assembled_ = false; } | 43 | void setMinute( int m ) { minute_ = m; assembled_ = false; } |
44 | 44 | ||
45 | bool positive() { parse(); return positive_; } | 45 | bool positive() { parse(); return positive_; } |
46 | unsigned int hour() { parse(); return hour_; } | 46 | unsigned int hour() { parse(); return hour_; } |
47 | unsigned int minute() { parse(); return minute_; } | 47 | unsigned int minute() { parse(); return minute_; } |
48 | 48 | ||
49 | private: | 49 | private: |
50 | 50 | ||
51 | bool positive_; | 51 | bool positive_; |
52 | unsigned int hour_; | 52 | unsigned int hour_; |
53 | unsigned int minute_; | 53 | unsigned int minute_; |
54 | }; | 54 | }; |
55 | 55 | ||
56 | } | 56 | } |
57 | 57 | ||
58 | #endif | 58 | #endif |
diff --git a/kabc/vcard/include/VCardVCard.h b/kabc/vcard/include/VCardVCard.h index 5dec166..5b66074 100644 --- a/kabc/vcard/include/VCardVCard.h +++ b/kabc/vcard/include/VCardVCard.h | |||
@@ -1,63 +1,65 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef VCARD_VCARD_H | 24 | #ifndef VCARD_VCARD_H |
25 | #define VCARD_VCARD_H | 25 | #define VCARD_VCARD_H |
26 | 26 | ||
27 | #include <qstring.h> | 27 | #include <qstring.h> |
28 | #include <qptrlist.h> | 28 | #include <q3ptrlist.h> |
29 | //Added by qt3to4: | ||
30 | #include <Q3CString> | ||
29 | 31 | ||
30 | #include <VCardEnum.h> | 32 | #include <VCardEnum.h> |
31 | #include <VCardEntity.h> | 33 | #include <VCardEntity.h> |
32 | #include <VCardContentLine.h> | 34 | #include <VCardContentLine.h> |
33 | 35 | ||
34 | namespace VCARD | 36 | namespace VCARD |
35 | { | 37 | { |
36 | 38 | ||
37 | class VCard : public Entity | 39 | class VCard : public Entity |
38 | { | 40 | { |
39 | 41 | ||
40 | #include "VCard-generated.h" | 42 | #include "VCard-generated.h" |
41 | 43 | ||
42 | bool has(EntityType); | 44 | bool has(EntityType); |
43 | bool has(const QCString &); | 45 | bool has(const Q3CString &); |
44 | 46 | ||
45 | void add(const ContentLine &); | 47 | void add(const ContentLine &); |
46 | void add(const QCString &); | 48 | void add(const Q3CString &); |
47 | 49 | ||
48 | ContentLine * contentLine(EntityType); | 50 | ContentLine * contentLine(EntityType); |
49 | ContentLine * contentLine(const QCString &); | 51 | ContentLine * contentLine(const Q3CString &); |
50 | 52 | ||
51 | QCString group() { parse(); return group_; } | 53 | Q3CString group() { parse(); return group_; } |
52 | 54 | ||
53 | QPtrList<ContentLine>contentLineList() { parse(); return contentLineList_; } | 55 | Q3PtrList<ContentLine>contentLineList() { parse(); return contentLineList_; } |
54 | 56 | ||
55 | private: | 57 | private: |
56 | 58 | ||
57 | QCString group_; | 59 | Q3CString group_; |
58 | QPtrList<ContentLine>contentLineList_; | 60 | Q3PtrList<ContentLine>contentLineList_; |
59 | }; | 61 | }; |
60 | 62 | ||
61 | } | 63 | } |
62 | 64 | ||
63 | #endif | 65 | #endif |
diff --git a/kabc/vcard/include/VCardVCardEntity.h b/kabc/vcard/include/VCardVCardEntity.h index 47ba370..8c824e7 100644 --- a/kabc/vcard/include/VCardVCardEntity.h +++ b/kabc/vcard/include/VCardVCardEntity.h | |||
@@ -1,56 +1,56 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef VCARD_ENTITY_H | 24 | #ifndef VCARD_ENTITY_H |
25 | #define VCARD_ENTITY_H | 25 | #define VCARD_ENTITY_H |
26 | 26 | ||
27 | #include <qstring.h> | 27 | #include <qstring.h> |
28 | #include <qptrlist.h> | 28 | #include <q3ptrlist.h> |
29 | 29 | ||
30 | #include <VCardEnum.h> | 30 | #include <VCardEnum.h> |
31 | #include <VCardVCard.h> | 31 | #include <VCardVCard.h> |
32 | #include <VCardEntity.h> | 32 | #include <VCardEntity.h> |
33 | 33 | ||
34 | namespace VCARD | 34 | namespace VCARD |
35 | { | 35 | { |
36 | 36 | ||
37 | typedef QPtrList<VCard> VCardList; | 37 | typedef Q3PtrList<VCard> VCardList; |
38 | typedef QPtrListIterator<VCard> VCardListIterator; | 38 | typedef Q3PtrListIterator<VCard> VCardListIterator; |
39 | 39 | ||
40 | class VCardEntity : public Entity | 40 | class VCardEntity : public Entity |
41 | { | 41 | { |
42 | 42 | ||
43 | #include "VCardEntity-generated.h" | 43 | #include "VCardEntity-generated.h" |
44 | 44 | ||
45 | void setCardList(const VCardList & l); | 45 | void setCardList(const VCardList & l); |
46 | VCardList & cardList(); | 46 | VCardList & cardList(); |
47 | 47 | ||
48 | private: | 48 | private: |
49 | 49 | ||
50 | VCardList cardList_; | 50 | VCardList cardList_; |
51 | 51 | ||
52 | }; | 52 | }; |
53 | 53 | ||
54 | } | 54 | } |
55 | 55 | ||
56 | #endif | 56 | #endif |
diff --git a/kabc/vcard/include/VCardValue.h b/kabc/vcard/include/VCardValue.h index 7cfe4a0..024397c 100644 --- a/kabc/vcard/include/VCardValue.h +++ b/kabc/vcard/include/VCardValue.h | |||
@@ -1,46 +1,46 @@ | |||
1 | /* | 1 | /* |
2 | libvcard - vCard parsing library for vCard version 3.0 | 2 | libvcard - vCard parsing library for vCard version 3.0 |
3 | 3 | ||
4 | Copyright (C) 1999 Rik Hemsley rik@kde.org | 4 | Copyright (C) 1999 Rik Hemsley rik@kde.org |
5 | 5 | ||
6 | Permission is hereby granted, free of charge, to any person obtaining a copy | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | of this software and associated documentation files (the "Software"), to | 7 | of this software and associated documentation files (the "Software"), to |
8 | deal in the Software without restriction, including without limitation the | 8 | deal in the Software without restriction, including without limitation the |
9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
10 | sell copies of the Software, and to permit persons to whom the Software is | 10 | sell copies of the Software, and to permit persons to whom the Software is |
11 | furnished to do so, subject to the following conditions: | 11 | furnished to do so, subject to the following conditions: |
12 | 12 | ||
13 | The above copyright notice and this permission notice shall be included in | 13 | The above copyright notice and this permission notice shall be included in |
14 | all copies or substantial portions of the Software. | 14 | all copies or substantial portions of the Software. |
15 | 15 | ||
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | 19 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | 20 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
22 | */ | 22 | */ |
23 | 23 | ||
24 | #ifndef VALUE_H | 24 | #ifndef VALUE_H |
25 | #define VALUE_H | 25 | #define VALUE_H |
26 | 26 | ||
27 | #include <qptrlist.h> | 27 | #include <q3ptrlist.h> |
28 | 28 | ||
29 | #include <VCardEntity.h> | 29 | #include <VCardEntity.h> |
30 | 30 | ||
31 | namespace VCARD | 31 | namespace VCARD |
32 | { | 32 | { |
33 | 33 | ||
34 | class Value : public Entity | 34 | class Value : public Entity |
35 | { | 35 | { |
36 | #include "Value-generated.h" | 36 | #include "Value-generated.h" |
37 | 37 | ||
38 | virtual Value *clone() { return new Value( *this ); } | 38 | virtual Value *clone() { return new Value( *this ); } |
39 | }; | 39 | }; |
40 | 40 | ||
41 | typedef QPtrList<Value> ValueList; | 41 | typedef Q3PtrList<Value> ValueList; |
42 | typedef QPtrListIterator<Value> ValueListIterator; | 42 | typedef Q3PtrListIterator<Value> ValueListIterator; |
43 | 43 | ||
44 | } | 44 | } |
45 | 45 | ||
46 | #endif | 46 | #endif |
diff --git a/kabc/vcard/include/generated/AdrParam-generated.h b/kabc/vcard/include/generated/AdrParam-generated.h index 3e265d8..a11d142 100644 --- a/kabc/vcard/include/generated/AdrParam-generated.h +++ b/kabc/vcard/include/generated/AdrParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | AdrParam(); | 6 | AdrParam(); |
5 | AdrParam(const AdrParam&); | 7 | AdrParam(const AdrParam&); |
6 | AdrParam(const QCString&); | 8 | AdrParam(const Q3CString&); |
7 | AdrParam & operator = (AdrParam&); | 9 | AdrParam & operator = (AdrParam&); |
8 | AdrParam & operator = (const QCString&); | 10 | AdrParam & operator = (const Q3CString&); |
9 | bool operator ==(AdrParam&); | 11 | bool operator ==(AdrParam&); |
10 | bool operator !=(AdrParam& x) {return !(*this==x);} | 12 | bool operator !=(AdrParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {AdrParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {AdrParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~AdrParam(); | 16 | virtual ~AdrParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "AdrParam"; } | 23 | const char * className() const { return "AdrParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/AdrValue-generated.h b/kabc/vcard/include/generated/AdrValue-generated.h index e1d93e4..c0a33a3 100644 --- a/kabc/vcard/include/generated/AdrValue-generated.h +++ b/kabc/vcard/include/generated/AdrValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | AdrValue(); | 6 | AdrValue(); |
5 | AdrValue(const AdrValue&); | 7 | AdrValue(const AdrValue&); |
6 | AdrValue(const QCString&); | 8 | AdrValue(const Q3CString&); |
7 | AdrValue & operator = (AdrValue&); | 9 | AdrValue & operator = (AdrValue&); |
8 | AdrValue & operator = (const QCString&); | 10 | AdrValue & operator = (const Q3CString&); |
9 | bool operator ==(AdrValue&); | 11 | bool operator ==(AdrValue&); |
10 | bool operator !=(AdrValue& x) {return !(*this==x);} | 12 | bool operator !=(AdrValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {AdrValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {AdrValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~AdrValue(); | 16 | virtual ~AdrValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "AdrValue"; } | 23 | const char * className() const { return "AdrValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/AgentParam-generated.h b/kabc/vcard/include/generated/AgentParam-generated.h index 6423867..d5ed988 100644 --- a/kabc/vcard/include/generated/AgentParam-generated.h +++ b/kabc/vcard/include/generated/AgentParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | AgentParam(); | 6 | AgentParam(); |
5 | AgentParam(const AgentParam&); | 7 | AgentParam(const AgentParam&); |
6 | AgentParam(const QCString&); | 8 | AgentParam(const Q3CString&); |
7 | AgentParam & operator = (AgentParam&); | 9 | AgentParam & operator = (AgentParam&); |
8 | AgentParam & operator = (const QCString&); | 10 | AgentParam & operator = (const Q3CString&); |
9 | bool operator ==(AgentParam&); | 11 | bool operator ==(AgentParam&); |
10 | bool operator !=(AgentParam& x) {return !(*this==x);} | 12 | bool operator !=(AgentParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {AgentParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {AgentParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~AgentParam(); | 16 | virtual ~AgentParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "AgentParam"; } | 23 | const char * className() const { return "AgentParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/AgentValue-generated.h b/kabc/vcard/include/generated/AgentValue-generated.h index 76bb81c..eef5277 100644 --- a/kabc/vcard/include/generated/AgentValue-generated.h +++ b/kabc/vcard/include/generated/AgentValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | AgentValue(); | 6 | AgentValue(); |
5 | AgentValue(const AgentValue&); | 7 | AgentValue(const AgentValue&); |
6 | AgentValue(const QCString&); | 8 | AgentValue(const Q3CString&); |
7 | AgentValue & operator = (AgentValue&); | 9 | AgentValue & operator = (AgentValue&); |
8 | AgentValue & operator = (const QCString&); | 10 | AgentValue & operator = (const Q3CString&); |
9 | bool operator ==(AgentValue&); | 11 | bool operator ==(AgentValue&); |
10 | bool operator !=(AgentValue& x) {return !(*this==x);} | 12 | bool operator !=(AgentValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {AgentValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {AgentValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~AgentValue(); | 16 | virtual ~AgentValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "AgentValue"; } | 23 | const char * className() const { return "AgentValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ClassValue-generated.h b/kabc/vcard/include/generated/ClassValue-generated.h index df4ed5f..b84c98f 100644 --- a/kabc/vcard/include/generated/ClassValue-generated.h +++ b/kabc/vcard/include/generated/ClassValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ClassValue(); | 6 | ClassValue(); |
5 | ClassValue(const ClassValue&); | 7 | ClassValue(const ClassValue&); |
6 | ClassValue(const QCString&); | 8 | ClassValue(const Q3CString&); |
7 | ClassValue & operator = (ClassValue&); | 9 | ClassValue & operator = (ClassValue&); |
8 | ClassValue & operator = (const QCString&); | 10 | ClassValue & operator = (const Q3CString&); |
9 | bool operator ==(ClassValue&); | 11 | bool operator ==(ClassValue&); |
10 | bool operator !=(ClassValue& x) {return !(*this==x);} | 12 | bool operator !=(ClassValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ClassValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ClassValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ClassValue(); | 16 | virtual ~ClassValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "ClassValue"; } | 23 | const char * className() const { return "ClassValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ContentLine-generated.h b/kabc/vcard/include/generated/ContentLine-generated.h index 9efe273..84d0822 100644 --- a/kabc/vcard/include/generated/ContentLine-generated.h +++ b/kabc/vcard/include/generated/ContentLine-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ContentLine(); | 6 | ContentLine(); |
5 | ContentLine(const ContentLine&); | 7 | ContentLine(const ContentLine&); |
6 | ContentLine(const QCString&); | 8 | ContentLine(const Q3CString&); |
7 | ContentLine & operator = (ContentLine&); | 9 | ContentLine & operator = (ContentLine&); |
8 | ContentLine & operator = (const QCString&); | 10 | ContentLine & operator = (const Q3CString&); |
9 | bool operator ==(ContentLine&); | 11 | bool operator ==(ContentLine&); |
10 | bool operator !=(ContentLine& x) {return !(*this==x);} | 12 | bool operator !=(ContentLine& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ContentLine a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ContentLine a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ContentLine(); | 16 | virtual ~ContentLine(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "ContentLine"; } | 23 | const char * className() const { return "ContentLine"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/DateParam-generated.h b/kabc/vcard/include/generated/DateParam-generated.h index ff1da58..029c1da 100644 --- a/kabc/vcard/include/generated/DateParam-generated.h +++ b/kabc/vcard/include/generated/DateParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | DateParam(); | 6 | DateParam(); |
5 | DateParam(const DateParam&); | 7 | DateParam(const DateParam&); |
6 | DateParam(const QCString&); | 8 | DateParam(const Q3CString&); |
7 | DateParam & operator = (DateParam&); | 9 | DateParam & operator = (DateParam&); |
8 | DateParam & operator = (const QCString&); | 10 | DateParam & operator = (const Q3CString&); |
9 | bool operator ==(DateParam&); | 11 | bool operator ==(DateParam&); |
10 | bool operator !=(DateParam& x) {return !(*this==x);} | 12 | bool operator !=(DateParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {DateParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {DateParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~DateParam(); | 16 | virtual ~DateParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "DateParam"; } | 23 | const char * className() const { return "DateParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/DateValue-generated.h b/kabc/vcard/include/generated/DateValue-generated.h index a382823..70eecce 100644 --- a/kabc/vcard/include/generated/DateValue-generated.h +++ b/kabc/vcard/include/generated/DateValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | DateValue(); | 6 | DateValue(); |
5 | DateValue(const DateValue&); | 7 | DateValue(const DateValue&); |
6 | DateValue(const QCString&); | 8 | DateValue(const Q3CString&); |
7 | DateValue & operator = (DateValue&); | 9 | DateValue & operator = (DateValue&); |
8 | DateValue & operator = (const QCString&); | 10 | DateValue & operator = (const Q3CString&); |
9 | bool operator ==(DateValue&); | 11 | bool operator ==(DateValue&); |
10 | bool operator !=(DateValue& x) {return !(*this==x);} | 12 | bool operator !=(DateValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {DateValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {DateValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~DateValue(); | 16 | virtual ~DateValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "DateValue"; } | 23 | const char * className() const { return "DateValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/EmailParam-generated.h b/kabc/vcard/include/generated/EmailParam-generated.h index 428a6fc..f498931 100644 --- a/kabc/vcard/include/generated/EmailParam-generated.h +++ b/kabc/vcard/include/generated/EmailParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | EmailParam(); | 6 | EmailParam(); |
5 | EmailParam(const EmailParam&); | 7 | EmailParam(const EmailParam&); |
6 | EmailParam(const QCString&); | 8 | EmailParam(const Q3CString&); |
7 | EmailParam & operator = (EmailParam&); | 9 | EmailParam & operator = (EmailParam&); |
8 | EmailParam & operator = (const QCString&); | 10 | EmailParam & operator = (const Q3CString&); |
9 | bool operator ==(EmailParam&); | 11 | bool operator ==(EmailParam&); |
10 | bool operator !=(EmailParam& x) {return !(*this==x);} | 12 | bool operator !=(EmailParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {EmailParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {EmailParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~EmailParam(); | 16 | virtual ~EmailParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "EmailParam"; } | 23 | const char * className() const { return "EmailParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/FloatValue-generated.h b/kabc/vcard/include/generated/FloatValue-generated.h index cac55cf..c04b85f 100644 --- a/kabc/vcard/include/generated/FloatValue-generated.h +++ b/kabc/vcard/include/generated/FloatValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | FloatValue(); | 6 | FloatValue(); |
5 | FloatValue(const FloatValue&); | 7 | FloatValue(const FloatValue&); |
6 | FloatValue(const QCString&); | 8 | FloatValue(const Q3CString&); |
7 | FloatValue & operator = (FloatValue&); | 9 | FloatValue & operator = (FloatValue&); |
8 | FloatValue & operator = (const QCString&); | 10 | FloatValue & operator = (const Q3CString&); |
9 | bool operator ==(FloatValue&); | 11 | bool operator ==(FloatValue&); |
10 | bool operator !=(FloatValue& x) {return !(*this==x);} | 12 | bool operator !=(FloatValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {FloatValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {FloatValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~FloatValue(); | 16 | virtual ~FloatValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "FloatValue"; } | 23 | const char * className() const { return "FloatValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/GeoValue-generated.h b/kabc/vcard/include/generated/GeoValue-generated.h index 594f3ad..ab659bf 100644 --- a/kabc/vcard/include/generated/GeoValue-generated.h +++ b/kabc/vcard/include/generated/GeoValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | GeoValue(); | 6 | GeoValue(); |
5 | GeoValue(const GeoValue&); | 7 | GeoValue(const GeoValue&); |
6 | GeoValue(const QCString&); | 8 | GeoValue(const Q3CString&); |
7 | GeoValue & operator = (GeoValue&); | 9 | GeoValue & operator = (GeoValue&); |
8 | GeoValue & operator = (const QCString&); | 10 | GeoValue & operator = (const Q3CString&); |
9 | bool operator ==(GeoValue&); | 11 | bool operator ==(GeoValue&); |
10 | bool operator !=(GeoValue& x) {return !(*this==x);} | 12 | bool operator !=(GeoValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {GeoValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {GeoValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~GeoValue(); | 16 | virtual ~GeoValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "GeoValue"; } | 23 | const char * className() const { return "GeoValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/Group-generated.h b/kabc/vcard/include/generated/Group-generated.h index f39302d..ae16e3d 100644 --- a/kabc/vcard/include/generated/Group-generated.h +++ b/kabc/vcard/include/generated/Group-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | Group(); | 6 | Group(); |
5 | Group(const Group&); | 7 | Group(const Group&); |
6 | Group(const QCString&); | 8 | Group(const Q3CString&); |
7 | Group & operator = (Group&); | 9 | Group & operator = (Group&); |
8 | Group & operator = (const QCString&); | 10 | Group & operator = (const Q3CString&); |
9 | bool operator ==(Group&); | 11 | bool operator ==(Group&); |
10 | bool operator !=(Group& x) {return !(*this==x);} | 12 | bool operator !=(Group& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {Group a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {Group a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~Group(); | 16 | virtual ~Group(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "Group"; } | 23 | const char * className() const { return "Group"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ImageParam-generated.h b/kabc/vcard/include/generated/ImageParam-generated.h index 81edfd2..91b09a4 100644 --- a/kabc/vcard/include/generated/ImageParam-generated.h +++ b/kabc/vcard/include/generated/ImageParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ImageParam(); | 6 | ImageParam(); |
5 | ImageParam(const ImageParam&); | 7 | ImageParam(const ImageParam&); |
6 | ImageParam(const QCString&); | 8 | ImageParam(const Q3CString&); |
7 | ImageParam & operator = (ImageParam&); | 9 | ImageParam & operator = (ImageParam&); |
8 | ImageParam & operator = (const QCString&); | 10 | ImageParam & operator = (const Q3CString&); |
9 | bool operator ==(ImageParam&); | 11 | bool operator ==(ImageParam&); |
10 | bool operator !=(ImageParam& x) {return !(*this==x);} | 12 | bool operator !=(ImageParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ImageParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ImageParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ImageParam(); | 16 | virtual ~ImageParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "ImageParam"; } | 23 | const char * className() const { return "ImageParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ImageValue-generated.h b/kabc/vcard/include/generated/ImageValue-generated.h index 5a2c493..d71282e 100644 --- a/kabc/vcard/include/generated/ImageValue-generated.h +++ b/kabc/vcard/include/generated/ImageValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ImageValue(); | 6 | ImageValue(); |
5 | ImageValue(const ImageValue&); | 7 | ImageValue(const ImageValue&); |
6 | ImageValue(const QCString&); | 8 | ImageValue(const Q3CString&); |
7 | ImageValue & operator = (ImageValue&); | 9 | ImageValue & operator = (ImageValue&); |
8 | ImageValue & operator = (const QCString&); | 10 | ImageValue & operator = (const Q3CString&); |
9 | bool operator ==(ImageValue&); | 11 | bool operator ==(ImageValue&); |
10 | bool operator !=(ImageValue& x) {return !(*this==x);} | 12 | bool operator !=(ImageValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ImageValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ImageValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ImageValue(); | 16 | virtual ~ImageValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "ImageValue"; } | 23 | const char * className() const { return "ImageValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ImgParam-generated.h b/kabc/vcard/include/generated/ImgParam-generated.h index 46a6ca0..461ca6d 100644 --- a/kabc/vcard/include/generated/ImgParam-generated.h +++ b/kabc/vcard/include/generated/ImgParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ImgParam(); | 6 | ImgParam(); |
5 | ImgParam(const ImgParam&); | 7 | ImgParam(const ImgParam&); |
6 | ImgParam(const QCString&); | 8 | ImgParam(const Q3CString&); |
7 | ImgParam & operator = (ImgParam&); | 9 | ImgParam & operator = (ImgParam&); |
8 | ImgParam & operator = (const QCString&); | 10 | ImgParam & operator = (const Q3CString&); |
9 | bool operator ==(ImgParam&); | 11 | bool operator ==(ImgParam&); |
10 | bool operator !=(ImgParam& x) {return !(*this==x);} | 12 | bool operator !=(ImgParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ImgParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ImgParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ImgParam(); | 16 | virtual ~ImgParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | virtual const char * className() const { return "ImgParam"; } | 23 | virtual const char * className() const { return "ImgParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ImgValue-generated.h b/kabc/vcard/include/generated/ImgValue-generated.h index d75d545..80ee646 100644 --- a/kabc/vcard/include/generated/ImgValue-generated.h +++ b/kabc/vcard/include/generated/ImgValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | ImgValue(); | 6 | ImgValue(); |
5 | ImgValue(const ImgValue&); | 7 | ImgValue(const ImgValue&); |
6 | ImgValue(const QCString&); | 8 | ImgValue(const Q3CString&); |
7 | ImgValue & operator = (ImgValue&); | 9 | ImgValue & operator = (ImgValue&); |
8 | ImgValue & operator = (const QCString&); | 10 | ImgValue & operator = (const Q3CString&); |
9 | bool operator ==(ImgValue&); | 11 | bool operator ==(ImgValue&); |
10 | bool operator !=(ImgValue& x) {return !(*this==x);} | 12 | bool operator !=(ImgValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {ImgValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {ImgValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~ImgValue(); | 16 | virtual ~ImgValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | virtual const char * className() const { return "ImgValue"; } | 23 | virtual const char * className() const { return "ImgValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/LangValue-generated.h b/kabc/vcard/include/generated/LangValue-generated.h index 23e138b..434f762 100644 --- a/kabc/vcard/include/generated/LangValue-generated.h +++ b/kabc/vcard/include/generated/LangValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | LangValue(); | 6 | LangValue(); |
5 | LangValue(const LangValue&); | 7 | LangValue(const LangValue&); |
6 | LangValue(const QCString&); | 8 | LangValue(const Q3CString&); |
7 | LangValue & operator = (LangValue&); | 9 | LangValue & operator = (LangValue&); |
8 | LangValue & operator = (const QCString&); | 10 | LangValue & operator = (const Q3CString&); |
9 | bool operator ==(LangValue&); | 11 | bool operator ==(LangValue&); |
10 | bool operator !=(LangValue& x) {return !(*this==x);} | 12 | bool operator !=(LangValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {LangValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {LangValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~LangValue(); | 16 | virtual ~LangValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "LangValue"; } | 23 | const char * className() const { return "LangValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/NValue-generated.h b/kabc/vcard/include/generated/NValue-generated.h index 082c253..086810f 100644 --- a/kabc/vcard/include/generated/NValue-generated.h +++ b/kabc/vcard/include/generated/NValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | NValue(); | 6 | NValue(); |
5 | NValue(const NValue&); | 7 | NValue(const NValue&); |
6 | NValue(const QCString&); | 8 | NValue(const Q3CString&); |
7 | NValue & operator = (NValue&); | 9 | NValue & operator = (NValue&); |
8 | NValue & operator = (const QCString&); | 10 | NValue & operator = (const Q3CString&); |
9 | bool operator ==(NValue&); | 11 | bool operator ==(NValue&); |
10 | bool operator !=(NValue& x) {return !(*this==x);} | 12 | bool operator !=(NValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {NValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {NValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~NValue(); | 16 | virtual ~NValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "NValue"; } | 23 | const char * className() const { return "NValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/Name-generated.h b/kabc/vcard/include/generated/Name-generated.h index 0e69abd..a3bcb25 100644 --- a/kabc/vcard/include/generated/Name-generated.h +++ b/kabc/vcard/include/generated/Name-generated.h | |||
@@ -1,22 +1,24 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | V_Name(); | 6 | V_Name(); |
5 | V_Name(const V_Name&); | 7 | V_Name(const V_Name&); |
6 | V_Name(const QCString&); | 8 | V_Name(const Q3CString&); |
7 | V_Name & operator = (V_Name&); | 9 | V_Name & operator = (V_Name&); |
8 | V_Name & operator = (const QCString&); | 10 | V_Name & operator = (const Q3CString&); |
9 | bool operator ==(V_Name&); | 11 | bool operator ==(V_Name&); |
10 | bool operator !=(V_Name& x) {return !(*this==x);} | 12 | bool operator !=(V_Name& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {V_Name a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {V_Name a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~V_Name(); | 16 | virtual ~V_Name(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | 23 | ||
22 | // End of automatically generated code // | 24 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/OrgValue-generated.h b/kabc/vcard/include/generated/OrgValue-generated.h index 51eb1b7..275f56f 100644 --- a/kabc/vcard/include/generated/OrgValue-generated.h +++ b/kabc/vcard/include/generated/OrgValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | OrgValue(); | 6 | OrgValue(); |
5 | OrgValue(const OrgValue&); | 7 | OrgValue(const OrgValue&); |
6 | OrgValue(const QCString&); | 8 | OrgValue(const Q3CString&); |
7 | OrgValue & operator = (OrgValue&); | 9 | OrgValue & operator = (OrgValue&); |
8 | OrgValue & operator = (const QCString&); | 10 | OrgValue & operator = (const Q3CString&); |
9 | bool operator ==(OrgValue&); | 11 | bool operator ==(OrgValue&); |
10 | bool operator !=(OrgValue& x) {return !(*this==x);} | 12 | bool operator !=(OrgValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {OrgValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {OrgValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~OrgValue(); | 16 | virtual ~OrgValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "OrgValue"; } | 23 | const char * className() const { return "OrgValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/Param-generated.h b/kabc/vcard/include/generated/Param-generated.h index cf4666a..1a35166 100644 --- a/kabc/vcard/include/generated/Param-generated.h +++ b/kabc/vcard/include/generated/Param-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | Param(); | 6 | Param(); |
5 | Param(const Param&); | 7 | Param(const Param&); |
6 | Param(const QCString&); | 8 | Param(const Q3CString&); |
7 | Param & operator = (Param&); | 9 | Param & operator = (Param&); |
8 | Param & operator = (const QCString&); | 10 | Param & operator = (const Q3CString&); |
9 | bool operator ==(Param&); | 11 | bool operator ==(Param&); |
10 | bool operator !=(Param& x) {return !(*this==x);} | 12 | bool operator !=(Param& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {Param a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {Param a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~Param(); | 16 | virtual ~Param(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "Param"; } | 23 | const char * className() const { return "Param"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ParamName-generated.h b/kabc/vcard/include/generated/ParamName-generated.h index ef673c3..b45022e 100644 --- a/kabc/vcard/include/generated/ParamName-generated.h +++ b/kabc/vcard/include/generated/ParamName-generated.h | |||
@@ -1,22 +1,24 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | V_ParamName(); | 6 | V_ParamName(); |
5 | V_ParamName(const V_ParamName&); | 7 | V_ParamName(const V_ParamName&); |
6 | V_ParamName(const QCString&); | 8 | V_ParamName(const Q3CString&); |
7 | V_ParamName & operator = (V_ParamName&); | 9 | V_ParamName & operator = (V_ParamName&); |
8 | V_ParamName & operator = (const QCString&); | 10 | V_ParamName & operator = (const Q3CString&); |
9 | bool operator ==(V_ParamName&); | 11 | bool operator ==(V_ParamName&); |
10 | bool operator !=(V_ParamName& x) {return !(*this==x);} | 12 | bool operator !=(V_ParamName& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {V_ParamName a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {V_ParamName a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~V_ParamName(); | 16 | virtual ~V_ParamName(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | 23 | ||
22 | // End of automatically generated code // | 24 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/ParamValue-generated.h b/kabc/vcard/include/generated/ParamValue-generated.h index e73500f..956c8da 100644 --- a/kabc/vcard/include/generated/ParamValue-generated.h +++ b/kabc/vcard/include/generated/ParamValue-generated.h | |||
@@ -1,22 +1,24 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | V_ParamValue(); | 6 | V_ParamValue(); |
5 | V_ParamValue(const V_ParamValue&); | 7 | V_ParamValue(const V_ParamValue&); |
6 | V_ParamValue(const QCString&); | 8 | V_ParamValue(const Q3CString&); |
7 | V_ParamValue & operator = (V_ParamValue&); | 9 | V_ParamValue & operator = (V_ParamValue&); |
8 | V_ParamValue & operator = (const QCString&); | 10 | V_ParamValue & operator = (const Q3CString&); |
9 | bool operator ==(V_ParamValue&); | 11 | bool operator ==(V_ParamValue&); |
10 | bool operator !=(V_ParamValue& x) {return !(*this==x);} | 12 | bool operator !=(V_ParamValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {V_ParamValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {V_ParamValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~V_ParamValue(); | 16 | virtual ~V_ParamValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | 23 | ||
22 | // End of automatically generated code // | 24 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/PhoneNumberValue-generated.h b/kabc/vcard/include/generated/PhoneNumberValue-generated.h index 1320f18..0d206f4 100644 --- a/kabc/vcard/include/generated/PhoneNumberValue-generated.h +++ b/kabc/vcard/include/generated/PhoneNumberValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | PhoneNumberValue(); | 6 | PhoneNumberValue(); |
5 | PhoneNumberValue(const PhoneNumberValue&); | 7 | PhoneNumberValue(const PhoneNumberValue&); |
6 | PhoneNumberValue(const QCString&); | 8 | PhoneNumberValue(const Q3CString&); |
7 | PhoneNumberValue & operator = (PhoneNumberValue&); | 9 | PhoneNumberValue & operator = (PhoneNumberValue&); |
8 | PhoneNumberValue & operator = (const QCString&); | 10 | PhoneNumberValue & operator = (const Q3CString&); |
9 | bool operator ==(PhoneNumberValue&); | 11 | bool operator ==(PhoneNumberValue&); |
10 | bool operator !=(PhoneNumberValue& x) {return !(*this==x);} | 12 | bool operator !=(PhoneNumberValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {PhoneNumberValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {PhoneNumberValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~PhoneNumberValue(); | 16 | virtual ~PhoneNumberValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "PhoneNumberValue"; } | 23 | const char * className() const { return "PhoneNumberValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/SoundValue-generated.h b/kabc/vcard/include/generated/SoundValue-generated.h index a9ab2e8..2cc9c0d 100644 --- a/kabc/vcard/include/generated/SoundValue-generated.h +++ b/kabc/vcard/include/generated/SoundValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | SoundValue(); | 6 | SoundValue(); |
5 | SoundValue(const SoundValue&); | 7 | SoundValue(const SoundValue&); |
6 | SoundValue(const QCString&); | 8 | SoundValue(const Q3CString&); |
7 | SoundValue & operator = (SoundValue&); | 9 | SoundValue & operator = (SoundValue&); |
8 | SoundValue & operator = (const QCString&); | 10 | SoundValue & operator = (const Q3CString&); |
9 | bool operator ==(SoundValue&); | 11 | bool operator ==(SoundValue&); |
10 | bool operator !=(SoundValue& x) {return !(*this==x);} | 12 | bool operator !=(SoundValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {SoundValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {SoundValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~SoundValue(); | 16 | virtual ~SoundValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "SoundValue"; } | 23 | const char * className() const { return "SoundValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/SourceParam-generated.h b/kabc/vcard/include/generated/SourceParam-generated.h index 75fefb8..537e093 100644 --- a/kabc/vcard/include/generated/SourceParam-generated.h +++ b/kabc/vcard/include/generated/SourceParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | SourceParam(); | 6 | SourceParam(); |
5 | SourceParam(const SourceParam&); | 7 | SourceParam(const SourceParam&); |
6 | SourceParam(const QCString&); | 8 | SourceParam(const Q3CString&); |
7 | SourceParam & operator = (SourceParam&); | 9 | SourceParam & operator = (SourceParam&); |
8 | SourceParam & operator = (const QCString&); | 10 | SourceParam & operator = (const Q3CString&); |
9 | bool operator ==(SourceParam&); | 11 | bool operator ==(SourceParam&); |
10 | bool operator !=(SourceParam& x) {return !(*this==x);} | 12 | bool operator !=(SourceParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {SourceParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {SourceParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~SourceParam(); | 16 | virtual ~SourceParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "SourceParam"; } | 23 | const char * className() const { return "SourceParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TelParam-generated.h b/kabc/vcard/include/generated/TelParam-generated.h index 3ee77cc..8d9ba0f 100644 --- a/kabc/vcard/include/generated/TelParam-generated.h +++ b/kabc/vcard/include/generated/TelParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TelParam(); | 6 | TelParam(); |
5 | TelParam(const TelParam&); | 7 | TelParam(const TelParam&); |
6 | TelParam(const QCString&); | 8 | TelParam(const Q3CString&); |
7 | TelParam & operator = (TelParam&); | 9 | TelParam & operator = (TelParam&); |
8 | TelParam & operator = (const QCString&); | 10 | TelParam & operator = (const Q3CString&); |
9 | bool operator ==(TelParam&); | 11 | bool operator ==(TelParam&); |
10 | bool operator !=(TelParam& x) {return !(*this==x);} | 12 | bool operator !=(TelParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TelParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TelParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TelParam(); | 16 | virtual ~TelParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TelParam"; } | 23 | const char * className() const { return "TelParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TelValue-generated.h b/kabc/vcard/include/generated/TelValue-generated.h index 3213e1c..b72fa7d 100644 --- a/kabc/vcard/include/generated/TelValue-generated.h +++ b/kabc/vcard/include/generated/TelValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TelValue(); | 6 | TelValue(); |
5 | TelValue(const TelValue&); | 7 | TelValue(const TelValue&); |
6 | TelValue(const QCString&); | 8 | TelValue(const Q3CString&); |
7 | TelValue & operator = (TelValue&); | 9 | TelValue & operator = (TelValue&); |
8 | TelValue & operator = (const QCString&); | 10 | TelValue & operator = (const Q3CString&); |
9 | bool operator ==(TelValue&); | 11 | bool operator ==(TelValue&); |
10 | bool operator !=(TelValue& x) {return !(*this==x);} | 12 | bool operator !=(TelValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TelValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TelValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TelValue(); | 16 | virtual ~TelValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TelValue"; } | 23 | const char * className() const { return "TelValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextBinParam-generated.h b/kabc/vcard/include/generated/TextBinParam-generated.h index d075c10..2e433b0 100644 --- a/kabc/vcard/include/generated/TextBinParam-generated.h +++ b/kabc/vcard/include/generated/TextBinParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextBinParam(); | 6 | TextBinParam(); |
5 | TextBinParam(const TextBinParam&); | 7 | TextBinParam(const TextBinParam&); |
6 | TextBinParam(const QCString&); | 8 | TextBinParam(const Q3CString&); |
7 | TextBinParam & operator = (TextBinParam&); | 9 | TextBinParam & operator = (TextBinParam&); |
8 | TextBinParam & operator = (const QCString&); | 10 | TextBinParam & operator = (const Q3CString&); |
9 | bool operator ==(TextBinParam&); | 11 | bool operator ==(TextBinParam&); |
10 | bool operator !=(TextBinParam& x) {return !(*this==x);} | 12 | bool operator !=(TextBinParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextBinParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextBinParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextBinParam(); | 16 | virtual ~TextBinParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextBinParam"; } | 23 | const char * className() const { return "TextBinParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextBinValue-generated.h b/kabc/vcard/include/generated/TextBinValue-generated.h index e9553ac..bc3ad61 100644 --- a/kabc/vcard/include/generated/TextBinValue-generated.h +++ b/kabc/vcard/include/generated/TextBinValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextBinValue(); | 6 | TextBinValue(); |
5 | TextBinValue(const TextBinValue&); | 7 | TextBinValue(const TextBinValue&); |
6 | TextBinValue(const QCString&); | 8 | TextBinValue(const Q3CString&); |
7 | TextBinValue & operator = (TextBinValue&); | 9 | TextBinValue & operator = (TextBinValue&); |
8 | TextBinValue & operator = (const QCString&); | 10 | TextBinValue & operator = (const Q3CString&); |
9 | bool operator ==(TextBinValue&); | 11 | bool operator ==(TextBinValue&); |
10 | bool operator !=(TextBinValue& x) {return !(*this==x);} | 12 | bool operator !=(TextBinValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextBinValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextBinValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextBinValue(); | 16 | virtual ~TextBinValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextBinValue"; } | 23 | const char * className() const { return "TextBinValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextListValue-generated.h b/kabc/vcard/include/generated/TextListValue-generated.h index 9f46124..9df8a46 100644 --- a/kabc/vcard/include/generated/TextListValue-generated.h +++ b/kabc/vcard/include/generated/TextListValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextListValue(); | 6 | TextListValue(); |
5 | TextListValue(const TextListValue&); | 7 | TextListValue(const TextListValue&); |
6 | TextListValue(const QCString&); | 8 | TextListValue(const Q3CString&); |
7 | TextListValue & operator = (TextListValue&); | 9 | TextListValue & operator = (TextListValue&); |
8 | TextListValue & operator = (const QCString&); | 10 | TextListValue & operator = (const Q3CString&); |
9 | bool operator ==(TextListValue&); | 11 | bool operator ==(TextListValue&); |
10 | bool operator !=(TextListValue& x) {return !(*this==x);} | 12 | bool operator !=(TextListValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextListValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextListValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextListValue(); | 16 | virtual ~TextListValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextListValue"; } | 23 | const char * className() const { return "TextListValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextNSParam-generated.h b/kabc/vcard/include/generated/TextNSParam-generated.h index d7f58ca..8842bd6 100644 --- a/kabc/vcard/include/generated/TextNSParam-generated.h +++ b/kabc/vcard/include/generated/TextNSParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextNSParam(); | 6 | TextNSParam(); |
5 | TextNSParam(const TextNSParam&); | 7 | TextNSParam(const TextNSParam&); |
6 | TextNSParam(const QCString&); | 8 | TextNSParam(const Q3CString&); |
7 | TextNSParam & operator = (TextNSParam&); | 9 | TextNSParam & operator = (TextNSParam&); |
8 | TextNSParam & operator = (const QCString&); | 10 | TextNSParam & operator = (const Q3CString&); |
9 | bool operator ==(TextNSParam&); | 11 | bool operator ==(TextNSParam&); |
10 | bool operator !=(TextNSParam& x) {return !(*this==x);} | 12 | bool operator !=(TextNSParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextNSParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextNSParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextNSParam(); | 16 | virtual ~TextNSParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextNSParam"; } | 23 | const char * className() const { return "TextNSParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextParam-generated.h b/kabc/vcard/include/generated/TextParam-generated.h index 154e1bf..e56a8a5 100644 --- a/kabc/vcard/include/generated/TextParam-generated.h +++ b/kabc/vcard/include/generated/TextParam-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextParam(); | 6 | TextParam(); |
5 | TextParam(const TextParam&); | 7 | TextParam(const TextParam&); |
6 | TextParam(const QCString&); | 8 | TextParam(const Q3CString&); |
7 | TextParam & operator = (TextParam&); | 9 | TextParam & operator = (TextParam&); |
8 | TextParam & operator = (const QCString&); | 10 | TextParam & operator = (const Q3CString&); |
9 | bool operator ==(TextParam&); | 11 | bool operator ==(TextParam&); |
10 | bool operator !=(TextParam& x) {return !(*this==x);} | 12 | bool operator !=(TextParam& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextParam a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextParam a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextParam(); | 16 | virtual ~TextParam(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextParam"; } | 23 | const char * className() const { return "TextParam"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/TextValue-generated.h b/kabc/vcard/include/generated/TextValue-generated.h index e1c4dcc..3f205e0 100644 --- a/kabc/vcard/include/generated/TextValue-generated.h +++ b/kabc/vcard/include/generated/TextValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | TextValue(); | 6 | TextValue(); |
5 | TextValue(const TextValue&); | 7 | TextValue(const TextValue&); |
6 | TextValue(const QCString&); | 8 | TextValue(const Q3CString&); |
7 | TextValue & operator = (TextValue&); | 9 | TextValue & operator = (TextValue&); |
8 | TextValue & operator = (const QCString&); | 10 | TextValue & operator = (const Q3CString&); |
9 | bool operator ==(TextValue&); | 11 | bool operator ==(TextValue&); |
10 | bool operator !=(TextValue& x) {return !(*this==x);} | 12 | bool operator !=(TextValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {TextValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {TextValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~TextValue(); | 16 | virtual ~TextValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "TextValue"; } | 23 | const char * className() const { return "TextValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/URIValue-generated.h b/kabc/vcard/include/generated/URIValue-generated.h index dbcb5c1..464178f 100644 --- a/kabc/vcard/include/generated/URIValue-generated.h +++ b/kabc/vcard/include/generated/URIValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | URIValue(); | 6 | URIValue(); |
5 | URIValue(const URIValue&); | 7 | URIValue(const URIValue&); |
6 | URIValue(const QCString&); | 8 | URIValue(const Q3CString&); |
7 | URIValue & operator = (URIValue&); | 9 | URIValue & operator = (URIValue&); |
8 | URIValue & operator = (const QCString&); | 10 | URIValue & operator = (const Q3CString&); |
9 | bool operator ==(URIValue&); | 11 | bool operator ==(URIValue&); |
10 | bool operator !=(URIValue& x) {return !(*this==x);} | 12 | bool operator !=(URIValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {URIValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {URIValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~URIValue(); | 16 | virtual ~URIValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "URIValue"; } | 23 | const char * className() const { return "URIValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/UTCValue-generated.h b/kabc/vcard/include/generated/UTCValue-generated.h index 46e447b..1a34b5c 100644 --- a/kabc/vcard/include/generated/UTCValue-generated.h +++ b/kabc/vcard/include/generated/UTCValue-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | UTCValue(); | 6 | UTCValue(); |
5 | UTCValue(const UTCValue&); | 7 | UTCValue(const UTCValue&); |
6 | UTCValue(const QCString&); | 8 | UTCValue(const Q3CString&); |
7 | UTCValue & operator = (UTCValue&); | 9 | UTCValue & operator = (UTCValue&); |
8 | UTCValue & operator = (const QCString&); | 10 | UTCValue & operator = (const Q3CString&); |
9 | bool operator ==(UTCValue&); | 11 | bool operator ==(UTCValue&); |
10 | bool operator !=(UTCValue& x) {return !(*this==x);} | 12 | bool operator !=(UTCValue& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {UTCValue a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {UTCValue a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~UTCValue(); | 16 | virtual ~UTCValue(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "UTCValue"; } | 23 | const char * className() const { return "UTCValue"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/VCard-generated.h b/kabc/vcard/include/generated/VCard-generated.h index 4d7d96d..d09c789 100644 --- a/kabc/vcard/include/generated/VCard-generated.h +++ b/kabc/vcard/include/generated/VCard-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | VCard(); | 6 | VCard(); |
5 | VCard(const VCard&); | 7 | VCard(const VCard&); |
6 | VCard(const QCString&); | 8 | VCard(const Q3CString&); |
7 | VCard & operator = (VCard&); | 9 | VCard & operator = (VCard&); |
8 | VCard & operator = (const QCString&); | 10 | VCard & operator = (const Q3CString&); |
9 | bool operator ==(VCard&); | 11 | bool operator ==(VCard&); |
10 | bool operator !=(VCard& x) {return !(*this==x);} | 12 | bool operator !=(VCard& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {VCard a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {VCard a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~VCard(); | 16 | virtual ~VCard(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "VCard"; } | 23 | const char * className() const { return "VCard"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/VCardEntity-generated.h b/kabc/vcard/include/generated/VCardEntity-generated.h index 9f2dfbc..cbbe8e1 100644 --- a/kabc/vcard/include/generated/VCardEntity-generated.h +++ b/kabc/vcard/include/generated/VCardEntity-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | VCardEntity(); | 6 | VCardEntity(); |
5 | VCardEntity(const VCardEntity&); | 7 | VCardEntity(const VCardEntity&); |
6 | VCardEntity(const QCString&); | 8 | VCardEntity(const Q3CString&); |
7 | VCardEntity & operator = (VCardEntity&); | 9 | VCardEntity & operator = (VCardEntity&); |
8 | VCardEntity & operator = (const QCString&); | 10 | VCardEntity & operator = (const Q3CString&); |
9 | bool operator ==(VCardEntity&); | 11 | bool operator ==(VCardEntity&); |
10 | bool operator !=(VCardEntity& x) {return !(*this==x);} | 12 | bool operator !=(VCardEntity& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {VCardEntity a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {VCardEntity a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~VCardEntity(); | 16 | virtual ~VCardEntity(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "VCardEntity"; } | 23 | const char * className() const { return "VCardEntity"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/include/generated/Value-generated.h b/kabc/vcard/include/generated/Value-generated.h index 7afac34..142e720 100644 --- a/kabc/vcard/include/generated/Value-generated.h +++ b/kabc/vcard/include/generated/Value-generated.h | |||
@@ -1,23 +1,25 @@ | |||
1 | //Added by qt3to4: | ||
2 | #include <Q3CString> | ||
1 | // XXX Automatically generated. DO NOT EDIT! XXX // | 3 | // XXX Automatically generated. DO NOT EDIT! XXX // |
2 | 4 | ||
3 | public: | 5 | public: |
4 | Value(); | 6 | Value(); |
5 | Value(const Value&); | 7 | Value(const Value&); |
6 | Value(const QCString&); | 8 | Value(const Q3CString&); |
7 | Value & operator = (Value&); | 9 | Value & operator = (Value&); |
8 | Value & operator = (const QCString&); | 10 | Value & operator = (const Q3CString&); |
9 | bool operator ==(Value&); | 11 | bool operator ==(Value&); |
10 | bool operator !=(Value& x) {return !(*this==x);} | 12 | bool operator !=(Value& x) {return !(*this==x);} |
11 | bool operator ==(const QCString& s) {Value a(s);return(*this==a);} | 13 | bool operator ==(const Q3CString& s) {Value a(s);return(*this==a);} |
12 | bool operator != (const QCString& s) {return !(*this == s);} | 14 | bool operator != (const Q3CString& s) {return !(*this == s);} |
13 | 15 | ||
14 | virtual ~Value(); | 16 | virtual ~Value(); |
15 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} | 17 | void parse() {if(!parsed_) _parse();parsed_=true;assembled_=false;} |
16 | 18 | ||
17 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} | 19 | void assemble() {if(assembled_) return;parse();_assemble();assembled_=true;} |
18 | 20 | ||
19 | void _parse(); | 21 | void _parse(); |
20 | void _assemble(); | 22 | void _assemble(); |
21 | const char * className() const { return "Value"; } | 23 | const char * className() const { return "Value"; } |
22 | 24 | ||
23 | // End of automatically generated code // | 25 | // End of automatically generated code // |
diff --git a/kabc/vcard/testread.cpp b/kabc/vcard/testread.cpp index 919c661..4d66aaf 100644 --- a/kabc/vcard/testread.cpp +++ b/kabc/vcard/testread.cpp | |||
@@ -1,129 +1,131 @@ | |||
1 | #include <iostream> | 1 | #include <iostream> |
2 | #include <stdlib.h> | 2 | #include <stdlib.h> |
3 | #include <assert.h> | 3 | #include <assert.h> |
4 | 4 | ||
5 | #include <qfile.h> | 5 | #include <qfile.h> |
6 | #include <qtextstream.h> | 6 | #include <q3textstream.h> |
7 | //Added by qt3to4: | ||
8 | #include <Q3CString> | ||
7 | 9 | ||
8 | #include <VCard.h> | 10 | #include <VCard.h> |
9 | 11 | ||
10 | using namespace std; | 12 | using namespace std; |
11 | 13 | ||
12 | int main(int argc, char * argv[]) | 14 | int main(int argc, char * argv[]) |
13 | { | 15 | { |
14 | if (argc != 2) { | 16 | if (argc != 2) { |
15 | cerr << "Usage: " << argv[0] << " <filename>" << endl; | 17 | cerr << "Usage: " << argv[0] << " <filename>" << endl; |
16 | exit(1); | 18 | exit(1); |
17 | } | 19 | } |
18 | 20 | ||
19 | QFile f(argv[1]); | 21 | QFile f(argv[1]); |
20 | 22 | ||
21 | QCString str; | 23 | Q3CString str; |
22 | 24 | ||
23 | if (!f.open(IO_ReadOnly)) { | 25 | if (!f.open(QIODevice::ReadOnly)) { |
24 | cerr << "Couldn't open file \"" << argv[1] << endl; | 26 | cerr << "Couldn't open file \"" << argv[1] << endl; |
25 | exit(1); | 27 | exit(1); |
26 | } | 28 | } |
27 | 29 | ||
28 | QTextStream t(&f); | 30 | Q3TextStream t(&f); |
29 | 31 | ||
30 | while (!t.eof()) | 32 | while (!t.eof()) |
31 | str += t.readLine().utf8() + '\n'; | 33 | str += t.readLine().utf8() + '\n'; |
32 | 34 | ||
33 | using namespace VCARD; | 35 | using namespace VCARD; |
34 | 36 | ||
35 | // Iterate through all vCards in the file. | 37 | // Iterate through all vCards in the file. |
36 | 38 | ||
37 | cout << "--------- begin ----------" << endl; | 39 | cout << "--------- begin ----------" << endl; |
38 | cout << str.data(); | 40 | cout << str.data(); |
39 | cout << "--------- end ----------" << endl; | 41 | cout << "--------- end ----------" << endl; |
40 | 42 | ||
41 | VCardEntity e(str); | 43 | VCardEntity e(str); |
42 | 44 | ||
43 | VCardListIterator it(e.cardList()); | 45 | VCardListIterator it(e.cardList()); |
44 | 46 | ||
45 | for (; it.current(); ++it) { | 47 | for (; it.current(); ++it) { |
46 | 48 | ||
47 | cerr << "****************** VCARD ********************" << endl; | 49 | cerr << "****************** VCARD ********************" << endl; |
48 | 50 | ||
49 | // Create a vcard using the string representation. | 51 | // Create a vcard using the string representation. |
50 | VCard & v (*it.current()); | 52 | VCard & v (*it.current()); |
51 | 53 | ||
52 | if (v.has(EntityEmail)) { | 54 | if (v.has(EntityEmail)) { |
53 | cerr << "Email parameter found" << endl; | 55 | cerr << "Email parameter found" << endl; |
54 | 56 | ||
55 | QCString s = v.contentLine(EntityEmail)->value()->asString(); | 57 | Q3CString s = v.contentLine(EntityEmail)->value()->asString(); |
56 | 58 | ||
57 | cerr << "Email value == " << s << endl; | 59 | cerr << "Email value == " << s << endl; |
58 | } | 60 | } |
59 | 61 | ||
60 | if (v.has(EntityNickname)) { | 62 | if (v.has(EntityNickname)) { |
61 | cerr << "Nickname parameter found" << endl; | 63 | cerr << "Nickname parameter found" << endl; |
62 | 64 | ||
63 | cerr << "Nickname value == " << | 65 | cerr << "Nickname value == " << |
64 | v.contentLine(EntityNickname)->value()->asString() << | 66 | v.contentLine(EntityNickname)->value()->asString() << |
65 | endl; | 67 | endl; |
66 | } | 68 | } |
67 | 69 | ||
68 | if (v.has(EntityRevision)) { | 70 | if (v.has(EntityRevision)) { |
69 | 71 | ||
70 | cerr << "Revision parameter found" << endl; | 72 | cerr << "Revision parameter found" << endl; |
71 | 73 | ||
72 | DateValue * d = | 74 | DateValue * d = |
73 | (DateValue *) | 75 | (DateValue *) |
74 | v.contentLine(EntityRevision)->value(); | 76 | v.contentLine(EntityRevision)->value(); |
75 | 77 | ||
76 | assert(d != 0); | 78 | assert(d != 0); |
77 | 79 | ||
78 | cerr << "Revision date: " << endl; | 80 | cerr << "Revision date: " << endl; |
79 | cerr << "Day : " << d->day() << endl; | 81 | cerr << "Day : " << d->day() << endl; |
80 | cerr << "Month : " << d->month()<< endl; | 82 | cerr << "Month : " << d->month()<< endl; |
81 | cerr << "Year : " << d->year() << endl; | 83 | cerr << "Year : " << d->year() << endl; |
82 | 84 | ||
83 | if (d->hasTime()) { | 85 | if (d->hasTime()) { |
84 | cerr << "Revision date has a time component" << endl; | 86 | cerr << "Revision date has a time component" << endl; |
85 | cerr << "Revision time: " << endl; | 87 | cerr << "Revision time: " << endl; |
86 | cerr << "Hour : " << d->hour()<< endl; | 88 | cerr << "Hour : " << d->hour()<< endl; |
87 | cerr << "Minute : " << d->minute()<< endl; | 89 | cerr << "Minute : " << d->minute()<< endl; |
88 | cerr << "Second : " << d->second()<< endl; | 90 | cerr << "Second : " << d->second()<< endl; |
89 | 91 | ||
90 | } | 92 | } |
91 | else cerr << "Revision date does NOT have a time component" << endl; | 93 | else cerr << "Revision date does NOT have a time component" << endl; |
92 | } | 94 | } |
93 | 95 | ||
94 | if (v.has(EntityURL)) { | 96 | if (v.has(EntityURL)) { |
95 | cerr << "URL Parameter found" << endl; | 97 | cerr << "URL Parameter found" << endl; |
96 | 98 | ||
97 | cerr << "URL Value == " << | 99 | cerr << "URL Value == " << |
98 | v.contentLine(EntityURL)->value()->asString() << | 100 | v.contentLine(EntityURL)->value()->asString() << |
99 | endl; | 101 | endl; |
100 | 102 | ||
101 | URIValue * urlVal = | 103 | URIValue * urlVal = |
102 | (URIValue *)v.contentLine(EntityURL)->value(); | 104 | (URIValue *)v.contentLine(EntityURL)->value(); |
103 | 105 | ||
104 | assert(urlVal != 0); | 106 | assert(urlVal != 0); |
105 | 107 | ||
106 | cerr << "URL scheme == " << | 108 | cerr << "URL scheme == " << |
107 | urlVal->scheme() << endl; | 109 | urlVal->scheme() << endl; |
108 | 110 | ||
109 | cerr << "URL scheme specific part == " << | 111 | cerr << "URL scheme specific part == " << |
110 | urlVal->schemeSpecificPart() << endl; | 112 | urlVal->schemeSpecificPart() << endl; |
111 | } | 113 | } |
112 | 114 | ||
113 | if (v.has(EntityN)) { | 115 | if (v.has(EntityN)) { |
114 | cerr << "N Parameter found" << endl; | 116 | cerr << "N Parameter found" << endl; |
115 | 117 | ||
116 | NValue * n = | 118 | NValue * n = |
117 | (NValue *)(v.contentLine(EntityN)->value()); | 119 | (NValue *)(v.contentLine(EntityN)->value()); |
118 | 120 | ||
119 | cerr << "Family name == " << n->family()<< endl; | 121 | cerr << "Family name == " << n->family()<< endl; |
120 | cerr << "Given name == " << n->given()<< endl; | 122 | cerr << "Given name == " << n->given()<< endl; |
121 | cerr << "Middle name == " << n->middle()<< endl; | 123 | cerr << "Middle name == " << n->middle()<< endl; |
122 | cerr << "Prefix == " << n->prefix()<< endl; | 124 | cerr << "Prefix == " << n->prefix()<< endl; |
123 | cerr << "Suffix == " << n->suffix()<< endl; | 125 | cerr << "Suffix == " << n->suffix()<< endl; |
124 | } | 126 | } |
125 | 127 | ||
126 | cerr << "***************** END VCARD ******************" << endl; | 128 | cerr << "***************** END VCARD ******************" << endl; |
127 | } | 129 | } |
128 | } | 130 | } |
129 | 131 | ||
diff --git a/kabc/vcard/testwrite.cpp b/kabc/vcard/testwrite.cpp index e4bbe7b..846e51a 100644 --- a/kabc/vcard/testwrite.cpp +++ b/kabc/vcard/testwrite.cpp | |||
@@ -1,41 +1,43 @@ | |||
1 | #include <kaboutdata.h> | 1 | #include <kaboutdata.h> |
2 | #include <kapplication.h> | 2 | #include <kapplication.h> |
3 | #include <kdebug.h> | 3 | #include <kdebug.h> |
4 | #include <klocale.h> | 4 | #include <klocale.h> |
5 | #include <kcmdlineargs.h> | 5 | #include <kcmdlineargs.h> |
6 | 6 | ||
7 | #include <VCard.h> | 7 | #include <VCard.h> |
8 | //Added by qt3to4: | ||
9 | #include <Q3CString> | ||
8 | 10 | ||
9 | int main(int argc,char **argv) | 11 | int main(int argc,char **argv) |
10 | { | 12 | { |
11 | KAboutData aboutData("testwrite",I18N_NOOP("TestWritevCard"),"0.1"); | 13 | KAboutData aboutData("testwrite",I18N_NOOP("TestWritevCard"),"0.1"); |
12 | KCmdLineArgs::init(argc,argv,&aboutData); | 14 | KCmdLineArgs::init(argc,argv,&aboutData); |
13 | 15 | ||
14 | KApplication app; | 16 | KApplication app; |
15 | 17 | ||
16 | kdDebug() << "Test Write VCard" << endl; | 18 | kdDebug() << "Test Write VCard" << endl; |
17 | 19 | ||
18 | using namespace VCARD; | 20 | using namespace VCARD; |
19 | 21 | ||
20 | VCard v; | 22 | VCard v; |
21 | 23 | ||
22 | ContentLine cl1; | 24 | ContentLine cl1; |
23 | cl1.setName(EntityTypeToParamName(EntityName)); | 25 | cl1.setName(EntityTypeToParamName(EntityName)); |
24 | cl1.setValue(new TextValue("Hans Wurst")); | 26 | cl1.setValue(new TextValue("Hans Wurst")); |
25 | v.add(cl1); | 27 | v.add(cl1); |
26 | 28 | ||
27 | ContentLine cl2; | 29 | ContentLine cl2; |
28 | cl2.setName(EntityTypeToParamName(EntityTelephone)); | 30 | cl2.setName(EntityTypeToParamName(EntityTelephone)); |
29 | cl2.setValue(new TelValue("12345")); | 31 | cl2.setValue(new TelValue("12345")); |
30 | ParamList p; | 32 | ParamList p; |
31 | p.append( new TelParam("home") ); | 33 | p.append( new TelParam("home") ); |
32 | p.append( new TelParam("fax") ); | 34 | p.append( new TelParam("fax") ); |
33 | cl2.setParamList( p ); | 35 | cl2.setParamList( p ); |
34 | v.add(cl2); | 36 | v.add(cl2); |
35 | 37 | ||
36 | QCString str = v.asString(); | 38 | Q3CString str = v.asString(); |
37 | 39 | ||
38 | kdDebug() << "--- VCard begin ---" << endl | 40 | kdDebug() << "--- VCard begin ---" << endl |
39 | << str | 41 | << str |
40 | << "--- VCard end ---" << endl; | 42 | << "--- VCard end ---" << endl; |
41 | } | 43 | } |