1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_sw.hxx" 24 25 #include <swtypes.hxx> 26 #include <cmdid.h> 27 #include <hintids.hxx> 28 #include <svx/svxids.hrc> 29 #include <doc.hxx> 30 #include <docary.hxx> 31 #include <fmtcol.hxx> 32 #include <poolfmt.hxx> 33 #include <unocoll.hxx> 34 #include <unosett.hxx> 35 #include <fmtanchr.hxx> 36 #include <ndtxt.hxx> 37 #include <section.hxx> 38 #include <IMark.hxx> 39 #include <ftnidx.hxx> 40 #include <fmtftn.hxx> 41 #include <txtftn.hxx> 42 #include <fmtpdsc.hxx> 43 #include <pagedesc.hxx> 44 #include <vos/mutex.hxx> 45 #include <com/sun/star/text/XTextTableCursor.hpp> 46 #include <com/sun/star/text/XTextTablesSupplier.hpp> 47 #include <com/sun/star/text/TableColumnSeparator.hpp> 48 #include <com/sun/star/text/XTextTable.hpp> 49 #include <svl/PasswordHelper.hxx> 50 #include <svtools/unoimap.hxx> 51 #include <svtools/unoevent.hxx> 52 #include <unotbl.hxx> 53 #include <unostyle.hxx> 54 #include <unofield.hxx> 55 #include <unoidx.hxx> 56 #include <unoframe.hxx> 57 #include <unofootnote.hxx> 58 #include <vcl/svapp.hxx> 59 #include <fmtcntnt.hxx> 60 #include <authfld.hxx> 61 #include <SwXTextDefaults.hxx> 62 #include <unochart.hxx> 63 #include <comphelper/makesequence.hxx> 64 #include <comphelper/sequence.hxx> 65 #include <list> 66 #include <iterator> 67 #include <unosection.hxx> 68 #include <unoparagraph.hxx> 69 #include <unobookmark.hxx> 70 #include <unorefmark.hxx> 71 #include <unometa.hxx> 72 #include "docsh.hxx" 73 #include <switerator.hxx> 74 75 using ::rtl::OUString; 76 using namespace ::com::sun::star; 77 using namespace ::com::sun::star::document; 78 using namespace ::com::sun::star::uno; 79 using namespace ::com::sun::star::text; 80 using namespace ::com::sun::star::container; 81 using namespace ::com::sun::star::lang; 82 83 /****************************************************************************** 84 * 85 ******************************************************************************/ 86 struct ProvNamesId_Type 87 { 88 const char * pName; 89 sal_uInt16 nType; 90 }; 91 92 // note: this thing is indexed as an array, so do not insert/remove entries! 93 const ProvNamesId_Type __FAR_DATA aProvNamesId[] = 94 { 95 { "com.sun.star.text.TextTable", SW_SERVICE_TYPE_TEXTTABLE }, 96 { "com.sun.star.text.TextFrame", SW_SERVICE_TYPE_TEXTFRAME }, 97 { "com.sun.star.text.GraphicObject", SW_SERVICE_TYPE_GRAPHIC }, 98 { "com.sun.star.text.TextEmbeddedObject", SW_SERVICE_TYPE_OLE }, 99 { "com.sun.star.text.Bookmark", SW_SERVICE_TYPE_BOOKMARK }, 100 { "com.sun.star.text.Footnote", SW_SERVICE_TYPE_FOOTNOTE }, 101 { "com.sun.star.text.Endnote", SW_SERVICE_TYPE_ENDNOTE }, 102 { "com.sun.star.text.DocumentIndexMark", SW_SERVICE_TYPE_INDEXMARK }, 103 { "com.sun.star.text.DocumentIndex", SW_SERVICE_TYPE_INDEX }, 104 { "com.sun.star.text.ReferenceMark", SW_SERVICE_REFERENCE_MARK }, 105 { "com.sun.star.style.CharacterStyle", SW_SERVICE_STYLE_CHARACTER_STYLE }, 106 { "com.sun.star.style.ParagraphStyle", SW_SERVICE_STYLE_PARAGRAPH_STYLE }, 107 { "com.sun.star.style.FrameStyle", SW_SERVICE_STYLE_FRAME_STYLE }, 108 { "com.sun.star.style.PageStyle", SW_SERVICE_STYLE_PAGE_STYLE }, 109 { "com.sun.star.style.NumberingStyle", SW_SERVICE_STYLE_NUMBERING_STYLE }, 110 { "com.sun.star.text.ContentIndexMark", SW_SERVICE_CONTENT_INDEX_MARK }, 111 { "com.sun.star.text.ContentIndex", SW_SERVICE_CONTENT_INDEX }, 112 { "com.sun.star.text.UserIndexMark", SW_SERVICE_USER_INDEX_MARK }, 113 { "com.sun.star.text.UserIndex", SW_SERVICE_USER_INDEX }, 114 { "com.sun.star.text.TextSection", SW_SERVICE_TEXT_SECTION }, 115 { "com.sun.star.text.TextField.DateTime", SW_SERVICE_FIELDTYPE_DATETIME }, 116 { "com.sun.star.text.TextField.User", SW_SERVICE_FIELDTYPE_USER }, 117 { "com.sun.star.text.TextField.SetExpression", SW_SERVICE_FIELDTYPE_SET_EXP }, 118 { "com.sun.star.text.TextField.GetExpression", SW_SERVICE_FIELDTYPE_GET_EXP }, 119 { "com.sun.star.text.TextField.FileName", SW_SERVICE_FIELDTYPE_FILE_NAME }, 120 { "com.sun.star.text.TextField.PageNumber", SW_SERVICE_FIELDTYPE_PAGE_NUM }, 121 { "com.sun.star.text.TextField.Author", SW_SERVICE_FIELDTYPE_AUTHOR }, 122 { "com.sun.star.text.TextField.Chapter", SW_SERVICE_FIELDTYPE_CHAPTER }, 123 { "", SW_SERVICE_FIELDTYPE_DUMMY_0 }, 124 { "com.sun.star.text.TextField.GetReference", SW_SERVICE_FIELDTYPE_GET_REFERENCE }, 125 { "com.sun.star.text.TextField.ConditionalText", SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT }, 126 { "com.sun.star.text.TextField.Annotation", SW_SERVICE_FIELDTYPE_ANNOTATION }, 127 { "com.sun.star.text.TextField.Input", SW_SERVICE_FIELDTYPE_INPUT }, 128 { "com.sun.star.text.TextField.Macro", SW_SERVICE_FIELDTYPE_MACRO }, 129 { "com.sun.star.text.TextField.DDE", SW_SERVICE_FIELDTYPE_DDE }, 130 { "com.sun.star.text.TextField.HiddenParagraph", SW_SERVICE_FIELDTYPE_HIDDEN_PARA }, 131 { "" /*com.sun.star.text.TextField.DocumentInfo"*/, SW_SERVICE_FIELDTYPE_DOC_INFO }, 132 { "com.sun.star.text.TextField.TemplateName", SW_SERVICE_FIELDTYPE_TEMPLATE_NAME }, 133 { "com.sun.star.text.TextField.ExtendedUser", SW_SERVICE_FIELDTYPE_USER_EXT }, 134 { "com.sun.star.text.TextField.ReferencePageSet", SW_SERVICE_FIELDTYPE_REF_PAGE_SET }, 135 { "com.sun.star.text.TextField.ReferencePageGet", SW_SERVICE_FIELDTYPE_REF_PAGE_GET }, 136 { "com.sun.star.text.TextField.JumpEdit", SW_SERVICE_FIELDTYPE_JUMP_EDIT }, 137 { "com.sun.star.text.TextField.Script", SW_SERVICE_FIELDTYPE_SCRIPT }, 138 { "com.sun.star.text.TextField.DatabaseNextSet", SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET }, 139 { "com.sun.star.text.TextField.DatabaseNumberOfSet", SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET }, 140 { "com.sun.star.text.TextField.DatabaseSetNumber", SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM }, 141 { "com.sun.star.text.TextField.Database", SW_SERVICE_FIELDTYPE_DATABASE }, 142 { "com.sun.star.text.TextField.DatabaseName", SW_SERVICE_FIELDTYPE_DATABASE_NAME }, 143 { "com.sun.star.text.TextField.TableFormula", SW_SERVICE_FIELDTYPE_TABLE_FORMULA }, 144 { "com.sun.star.text.TextField.PageCount", SW_SERVICE_FIELDTYPE_PAGE_COUNT }, 145 { "com.sun.star.text.TextField.ParagraphCount", SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT }, 146 { "com.sun.star.text.TextField.WordCount", SW_SERVICE_FIELDTYPE_WORD_COUNT }, 147 { "com.sun.star.text.TextField.CharacterCount", SW_SERVICE_FIELDTYPE_CHARACTER_COUNT }, 148 { "com.sun.star.text.TextField.TableCount", SW_SERVICE_FIELDTYPE_TABLE_COUNT }, 149 { "com.sun.star.text.TextField.GraphicObjectCount", SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT }, 150 { "com.sun.star.text.TextField.EmbeddedObjectCount", SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT }, 151 { "com.sun.star.text.TextField.DocInfo.ChangeAuthor", SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR }, 152 { "com.sun.star.text.TextField.DocInfo.ChangeDateTime", SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME }, 153 { "com.sun.star.text.TextField.DocInfo.EditTime", SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME }, 154 { "com.sun.star.text.TextField.DocInfo.Description", SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION }, 155 { "com.sun.star.text.TextField.DocInfo.CreateAuthor", SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR }, 156 { "com.sun.star.text.TextField.DocInfo.CreateDateTime", SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME }, 157 { "", SW_SERVICE_FIELDTYPE_DUMMY_0 }, 158 { "", SW_SERVICE_FIELDTYPE_DUMMY_1 }, 159 { "", SW_SERVICE_FIELDTYPE_DUMMY_2 }, 160 { "", SW_SERVICE_FIELDTYPE_DUMMY_3 }, 161 { "com.sun.star.text.TextField.DocInfo.Custom", SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM }, 162 { "com.sun.star.text.TextField.DocInfo.PrintAuthor", SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR }, 163 { "com.sun.star.text.TextField.DocInfo.PrintDateTime", SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME }, 164 { "com.sun.star.text.TextField.DocInfo.KeyWords", SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS }, 165 { "com.sun.star.text.TextField.DocInfo.Subject", SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT }, 166 { "com.sun.star.text.TextField.DocInfo.Title", SW_SERVICE_FIELDTYPE_DOCINFO_TITLE }, 167 { "com.sun.star.text.TextField.DocInfo.Revision", SW_SERVICE_FIELDTYPE_DOCINFO_REVISION }, 168 { "com.sun.star.text.TextField.Bibliography", SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY }, 169 { "com.sun.star.text.TextField.CombinedCharacters", SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS }, 170 { "com.sun.star.text.TextField.DropDown", SW_SERVICE_FIELDTYPE_DROPDOWN }, 171 { "com.sun.star.text.textfield.MetadataField", SW_SERVICE_FIELDTYPE_METAFIELD }, 172 { "", SW_SERVICE_FIELDTYPE_DUMMY_4 }, 173 { "", SW_SERVICE_FIELDTYPE_DUMMY_5 }, 174 { "", SW_SERVICE_FIELDTYPE_DUMMY_6 }, 175 { "", SW_SERVICE_FIELDTYPE_DUMMY_7 }, 176 { "com.sun.star.text.FieldMaster.User", SW_SERVICE_FIELDMASTER_USER }, 177 { "com.sun.star.text.FieldMaster.DDE", SW_SERVICE_FIELDMASTER_DDE }, 178 { "com.sun.star.text.FieldMaster.SetExpression", SW_SERVICE_FIELDMASTER_SET_EXP }, 179 { "com.sun.star.text.FieldMaster.Database", SW_SERVICE_FIELDMASTER_DATABASE }, 180 { "com.sun.star.text.FieldMaster.Bibliography", SW_SERVICE_FIELDMASTER_BIBLIOGRAPHY }, 181 { "", SW_SERVICE_FIELDMASTER_DUMMY2 }, 182 { "", SW_SERVICE_FIELDMASTER_DUMMY3 }, 183 { "", SW_SERVICE_FIELDMASTER_DUMMY4 }, 184 { "", SW_SERVICE_FIELDMASTER_DUMMY5 }, 185 { "com.sun.star.text.IllustrationsIndex", SW_SERVICE_INDEX_ILLUSTRATIONS }, 186 { "com.sun.star.text.ObjectIndex", SW_SERVICE_INDEX_OBJECTS }, 187 { "com.sun.star.text.TableIndex", SW_SERVICE_INDEX_TABLES }, 188 { "com.sun.star.text.Bibliography", SW_SERVICE_INDEX_BIBLIOGRAPHY }, 189 { "com.sun.star.text.Paragraph", SW_SERVICE_PARAGRAPH }, 190 { "com.sun.star.text.TextField.InputUser", SW_SERVICE_FIELDTYPE_INPUT_USER }, 191 { "com.sun.star.text.TextField.HiddenText", SW_SERVICE_FIELDTYPE_HIDDEN_TEXT }, 192 { "com.sun.star.style.ConditionalParagraphStyle", SW_SERVICE_STYLE_CONDITIONAL_PARAGRAPH_STYLE }, 193 { "com.sun.star.text.NumberingRules", SW_SERVICE_NUMBERING_RULES }, 194 { "com.sun.star.text.TextColumns", SW_SERVICE_TEXT_COLUMNS }, 195 { "com.sun.star.text.IndexHeaderSection", SW_SERVICE_INDEX_HEADER_SECTION }, 196 { "com.sun.star.text.Defaults", SW_SERVICE_DEFAULTS }, 197 { "com.sun.star.image.ImageMapRectangleObject", SW_SERVICE_IMAP_RECTANGLE }, 198 { "com.sun.star.image.ImageMapCircleObject", SW_SERVICE_IMAP_CIRCLE }, 199 { "com.sun.star.image.ImageMapPolygonObject", SW_SERVICE_IMAP_POLYGON }, 200 { "com.sun.star.text.TextGraphicObject", SW_SERVICE_TYPE_TEXT_GRAPHIC }, 201 { "com.sun.star.chart2.data.DataProvider", SW_SERVICE_CHART2_DATA_PROVIDER }, 202 { "com.sun.star.text.Fieldmark", SW_SERVICE_TYPE_FIELDMARK }, 203 { "com.sun.star.text.FormFieldmark", SW_SERVICE_TYPE_FORMFIELDMARK }, 204 { "com.sun.star.text.InContentMetadata", SW_SERVICE_TYPE_META }, 205 206 // case-correct versions of the service names (see #i67811) 207 { CSS_TEXT_TEXTFIELD_DATE_TIME, SW_SERVICE_FIELDTYPE_DATETIME }, 208 { CSS_TEXT_TEXTFIELD_USER, SW_SERVICE_FIELDTYPE_USER }, 209 { CSS_TEXT_TEXTFIELD_SET_EXPRESSION, SW_SERVICE_FIELDTYPE_SET_EXP }, 210 { CSS_TEXT_TEXTFIELD_GET_EXPRESSION, SW_SERVICE_FIELDTYPE_GET_EXP }, 211 { CSS_TEXT_TEXTFIELD_FILE_NAME, SW_SERVICE_FIELDTYPE_FILE_NAME }, 212 { CSS_TEXT_TEXTFIELD_PAGE_NUMBER, SW_SERVICE_FIELDTYPE_PAGE_NUM }, 213 { CSS_TEXT_TEXTFIELD_AUTHOR, SW_SERVICE_FIELDTYPE_AUTHOR }, 214 { CSS_TEXT_TEXTFIELD_CHAPTER, SW_SERVICE_FIELDTYPE_CHAPTER }, 215 { CSS_TEXT_TEXTFIELD_GET_REFERENCE, SW_SERVICE_FIELDTYPE_GET_REFERENCE }, 216 { CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT, SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT }, 217 { CSS_TEXT_TEXTFIELD_ANNOTATION, SW_SERVICE_FIELDTYPE_ANNOTATION }, 218 { CSS_TEXT_TEXTFIELD_INPUT, SW_SERVICE_FIELDTYPE_INPUT }, 219 { CSS_TEXT_TEXTFIELD_MACRO, SW_SERVICE_FIELDTYPE_MACRO }, 220 { CSS_TEXT_TEXTFIELD_DDE, SW_SERVICE_FIELDTYPE_DDE }, 221 { CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH, SW_SERVICE_FIELDTYPE_HIDDEN_PARA }, 222 { CSS_TEXT_TEXTFIELD_TEMPLATE_NAME, SW_SERVICE_FIELDTYPE_TEMPLATE_NAME }, 223 { CSS_TEXT_TEXTFIELD_EXTENDED_USER, SW_SERVICE_FIELDTYPE_USER_EXT }, 224 { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET, SW_SERVICE_FIELDTYPE_REF_PAGE_SET }, 225 { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET, SW_SERVICE_FIELDTYPE_REF_PAGE_GET }, 226 { CSS_TEXT_TEXTFIELD_JUMP_EDIT, SW_SERVICE_FIELDTYPE_JUMP_EDIT }, 227 { CSS_TEXT_TEXTFIELD_SCRIPT, SW_SERVICE_FIELDTYPE_SCRIPT }, 228 { CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET, SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET }, 229 { CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET, SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET }, 230 { CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER, SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM }, 231 { CSS_TEXT_TEXTFIELD_DATABASE, SW_SERVICE_FIELDTYPE_DATABASE }, 232 { CSS_TEXT_TEXTFIELD_DATABASE_NAME, SW_SERVICE_FIELDTYPE_DATABASE_NAME }, 233 { CSS_TEXT_TEXTFIELD_TABLE_FORMULA, SW_SERVICE_FIELDTYPE_TABLE_FORMULA }, 234 { CSS_TEXT_TEXTFIELD_PAGE_COUNT, SW_SERVICE_FIELDTYPE_PAGE_COUNT }, 235 { CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT, SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT }, 236 { CSS_TEXT_TEXTFIELD_WORD_COUNT, SW_SERVICE_FIELDTYPE_WORD_COUNT }, 237 { CSS_TEXT_TEXTFIELD_CHARACTER_COUNT, SW_SERVICE_FIELDTYPE_CHARACTER_COUNT }, 238 { CSS_TEXT_TEXTFIELD_TABLE_COUNT, SW_SERVICE_FIELDTYPE_TABLE_COUNT }, 239 { CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT, SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT }, 240 { CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT, SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT }, 241 { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR, SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR }, 242 { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME, SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME }, 243 { CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME, SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME }, 244 { CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION, SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION }, 245 { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR, SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR }, 246 { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME, SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME }, 247 { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR, SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR }, 248 { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME, SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME }, 249 { CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS, SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS }, 250 { CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT, SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT }, 251 { CSS_TEXT_TEXTFIELD_DOCINFO_TITLE, SW_SERVICE_FIELDTYPE_DOCINFO_TITLE }, 252 { CSS_TEXT_TEXTFIELD_DOCINFO_REVISION, SW_SERVICE_FIELDTYPE_DOCINFO_REVISION }, 253 { CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM, SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM }, 254 { CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY, SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY }, 255 { CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS, SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS }, 256 { CSS_TEXT_TEXTFIELD_DROP_DOWN, SW_SERVICE_FIELDTYPE_DROPDOWN }, 257 { CSS_TEXT_TEXTFIELD_INPUT_USER, SW_SERVICE_FIELDTYPE_INPUT_USER }, 258 { CSS_TEXT_TEXTFIELD_HIDDEN_TEXT, SW_SERVICE_FIELDTYPE_HIDDEN_TEXT }, 259 { CSS_TEXT_FIELDMASTER_USER, SW_SERVICE_FIELDMASTER_USER }, 260 { CSS_TEXT_FIELDMASTER_DDE, SW_SERVICE_FIELDMASTER_DDE }, 261 { CSS_TEXT_FIELDMASTER_SET_EXPRESSION, SW_SERVICE_FIELDMASTER_SET_EXP }, 262 { CSS_TEXT_FIELDMASTER_DATABASE, SW_SERVICE_FIELDMASTER_DATABASE }, 263 { CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY, SW_SERVICE_FIELDMASTER_BIBLIOGRAPHY } 264 }; 265 266 const SvEventDescription* lcl_GetSupportedMacroItems() 267 { 268 static const SvEventDescription aMacroDescriptionsImpl[] = 269 { 270 { SFX_EVENT_MOUSEOVER_OBJECT, "OnMouseOver" }, 271 { SFX_EVENT_MOUSEOUT_OBJECT, "OnMouseOut" }, 272 { 0, NULL } 273 }; 274 275 return aMacroDescriptionsImpl; 276 } 277 278 /****************************************************************** 279 * SwXServiceProvider 280 ******************************************************************/ 281 OUString SwXServiceProvider::GetProviderName(sal_uInt16 nObjectType) 282 { 283 vos::OGuard aGuard(Application::GetSolarMutex()); 284 OUString sRet; 285 sal_uInt16 nEntries = sizeof(aProvNamesId) / sizeof(aProvNamesId[0]); 286 if(nObjectType < nEntries) 287 sRet = C2U(aProvNamesId[nObjectType].pName); 288 return sRet; 289 } 290 291 uno::Sequence<OUString> SwXServiceProvider::GetAllServiceNames() 292 { 293 sal_uInt16 nEntries = sizeof(aProvNamesId) / sizeof(aProvNamesId[0]); 294 uno::Sequence<OUString> aRet(nEntries); 295 OUString* pArray = aRet.getArray(); 296 sal_uInt16 n = 0; 297 for(sal_uInt16 i = 0; i < nEntries; i++) 298 { 299 String sProv(C2U(aProvNamesId[i].pName)); 300 if(sProv.Len()) 301 { 302 pArray[n] = sProv; 303 n++; 304 } 305 } 306 aRet.realloc(n); 307 return aRet; 308 309 } 310 311 sal_uInt16 SwXServiceProvider::GetProviderType(const OUString& rServiceName) 312 { 313 sal_uInt16 nEntries = sizeof(aProvNamesId) / sizeof(aProvNamesId[0]); 314 for(sal_uInt16 i = 0; i < nEntries; i++ ) 315 { 316 if( COMPARE_EQUAL == rServiceName.compareToAscii(aProvNamesId[i].pName)) 317 return aProvNamesId[i].nType; 318 } 319 return SW_SERVICE_INVALID; 320 } 321 322 uno::Reference< uno::XInterface > SwXServiceProvider::MakeInstance(sal_uInt16 nObjectType, SwDoc* pDoc) 323 { 324 vos::OGuard aGuard(Application::GetSolarMutex()); 325 uno::Reference< uno::XInterface > xRet; 326 switch(nObjectType) 327 { 328 case SW_SERVICE_TYPE_TEXTTABLE: 329 { 330 SwXTextTable* pTextTable = new SwXTextTable(); 331 xRet = (cppu::OWeakObject*)pTextTable; 332 } 333 break; 334 case SW_SERVICE_TYPE_TEXTFRAME: 335 { 336 SwXTextFrame* pTextFrame = new SwXTextFrame( pDoc ); 337 xRet = (cppu::OWeakObject*)(SwXFrame*)pTextFrame; 338 } 339 break; 340 case SW_SERVICE_TYPE_GRAPHIC : 341 case SW_SERVICE_TYPE_TEXT_GRAPHIC /* #i47503# */ : 342 { 343 SwXTextGraphicObject* pGraphic = new SwXTextGraphicObject( pDoc ); 344 xRet = (cppu::OWeakObject*)(SwXFrame*)pGraphic; 345 346 } 347 break; 348 case SW_SERVICE_TYPE_OLE : 349 { 350 SwXTextEmbeddedObject* pOle = new SwXTextEmbeddedObject( pDoc ); 351 xRet = (cppu::OWeakObject*)(SwXFrame*)pOle; 352 } 353 break; 354 case SW_SERVICE_TYPE_BOOKMARK : 355 { 356 SwXBookmark* pBookmark = new SwXBookmark; 357 xRet = (cppu::OWeakObject*)pBookmark; 358 } 359 break; 360 case SW_SERVICE_TYPE_FIELDMARK : 361 { 362 SwXFieldmark* pFieldmark = new SwXFieldmark(false); 363 xRet = (cppu::OWeakObject*)pFieldmark; 364 } 365 break; 366 case SW_SERVICE_TYPE_FORMFIELDMARK : 367 { 368 SwXFieldmark* pFieldmark = new SwXFieldmark(true); 369 xRet = (cppu::OWeakObject*)pFieldmark; 370 } 371 break; 372 case SW_SERVICE_TYPE_FOOTNOTE : 373 xRet = (cppu::OWeakObject*)new SwXFootnote(sal_False); 374 break; 375 case SW_SERVICE_TYPE_ENDNOTE : 376 xRet = (cppu::OWeakObject*)new SwXFootnote(sal_True); 377 break; 378 case SW_SERVICE_CONTENT_INDEX_MARK : 379 case SW_SERVICE_USER_INDEX_MARK : 380 case SW_SERVICE_TYPE_INDEXMARK: 381 { 382 TOXTypes eType = TOX_INDEX; 383 if(SW_SERVICE_CONTENT_INDEX_MARK== nObjectType) 384 eType = TOX_CONTENT; 385 else if(SW_SERVICE_USER_INDEX_MARK == nObjectType) 386 eType = TOX_USER; 387 xRet = (cppu::OWeakObject*)new SwXDocumentIndexMark(eType); 388 } 389 break; 390 case SW_SERVICE_CONTENT_INDEX : 391 case SW_SERVICE_USER_INDEX : 392 case SW_SERVICE_TYPE_INDEX : 393 case SW_SERVICE_INDEX_ILLUSTRATIONS: 394 case SW_SERVICE_INDEX_OBJECTS : 395 case SW_SERVICE_INDEX_TABLES: 396 case SW_SERVICE_INDEX_BIBLIOGRAPHY : 397 { 398 TOXTypes eType = TOX_INDEX; 399 if(SW_SERVICE_CONTENT_INDEX == nObjectType) 400 eType = TOX_CONTENT; 401 else if(SW_SERVICE_USER_INDEX == nObjectType) 402 eType = TOX_USER; 403 else if(SW_SERVICE_INDEX_ILLUSTRATIONS == nObjectType) 404 { 405 eType = TOX_ILLUSTRATIONS; 406 } 407 else if(SW_SERVICE_INDEX_OBJECTS == nObjectType) 408 { 409 eType = TOX_OBJECTS; 410 } 411 else if(SW_SERVICE_INDEX_BIBLIOGRAPHY == nObjectType) 412 { 413 eType = TOX_AUTHORITIES; 414 } 415 else if(SW_SERVICE_INDEX_TABLES == nObjectType) 416 { 417 eType = TOX_TABLES; 418 } 419 xRet = (cppu::OWeakObject*)new SwXDocumentIndex(eType, *pDoc); 420 } 421 break; 422 case SW_SERVICE_INDEX_HEADER_SECTION : 423 case SW_SERVICE_TEXT_SECTION : 424 xRet = SwXTextSection::CreateXTextSection(0, 425 (SW_SERVICE_INDEX_HEADER_SECTION == nObjectType)); 426 427 break; 428 case SW_SERVICE_REFERENCE_MARK : 429 xRet = (cppu::OWeakObject*)new SwXReferenceMark(0, 0); 430 break; 431 case SW_SERVICE_STYLE_CHARACTER_STYLE: 432 case SW_SERVICE_STYLE_PARAGRAPH_STYLE: 433 case SW_SERVICE_STYLE_CONDITIONAL_PARAGRAPH_STYLE: 434 case SW_SERVICE_STYLE_FRAME_STYLE: 435 case SW_SERVICE_STYLE_PAGE_STYLE: 436 case SW_SERVICE_STYLE_NUMBERING_STYLE: 437 { 438 SfxStyleFamily eFamily = SFX_STYLE_FAMILY_CHAR; 439 switch(nObjectType) 440 { 441 case SW_SERVICE_STYLE_PARAGRAPH_STYLE: 442 case SW_SERVICE_STYLE_CONDITIONAL_PARAGRAPH_STYLE: 443 eFamily = SFX_STYLE_FAMILY_PARA; 444 break; 445 case SW_SERVICE_STYLE_FRAME_STYLE: 446 eFamily = SFX_STYLE_FAMILY_FRAME; 447 break; 448 case SW_SERVICE_STYLE_PAGE_STYLE: 449 eFamily = SFX_STYLE_FAMILY_PAGE; 450 break; 451 case SW_SERVICE_STYLE_NUMBERING_STYLE: 452 eFamily = SFX_STYLE_FAMILY_PSEUDO; 453 break; 454 } 455 SwXStyle* pNewStyle = SFX_STYLE_FAMILY_PAGE == eFamily ? 456 new SwXPageStyle(pDoc->GetDocShell()) : 457 eFamily == SFX_STYLE_FAMILY_FRAME ? 458 new SwXFrameStyle ( pDoc ): 459 new SwXStyle( pDoc, eFamily, nObjectType == SW_SERVICE_STYLE_CONDITIONAL_PARAGRAPH_STYLE); 460 xRet = (cppu::OWeakObject*)pNewStyle; 461 } 462 break; 463 // SW_SERVICE_DUMMY_5 464 // SW_SERVICE_DUMMY_6 465 // SW_SERVICE_DUMMY_7 466 // SW_SERVICE_DUMMY_8 467 // SW_SERVICE_DUMMY_9 468 case SW_SERVICE_FIELDTYPE_DATETIME: 469 case SW_SERVICE_FIELDTYPE_USER: 470 case SW_SERVICE_FIELDTYPE_SET_EXP: 471 case SW_SERVICE_FIELDTYPE_GET_EXP: 472 case SW_SERVICE_FIELDTYPE_FILE_NAME: 473 case SW_SERVICE_FIELDTYPE_PAGE_NUM: 474 case SW_SERVICE_FIELDTYPE_AUTHOR: 475 case SW_SERVICE_FIELDTYPE_CHAPTER: 476 case SW_SERVICE_FIELDTYPE_GET_REFERENCE: 477 case SW_SERVICE_FIELDTYPE_CONDITIONED_TEXT: 478 case SW_SERVICE_FIELDTYPE_INPUT: 479 case SW_SERVICE_FIELDTYPE_MACRO: 480 case SW_SERVICE_FIELDTYPE_DDE: 481 case SW_SERVICE_FIELDTYPE_HIDDEN_PARA: 482 case SW_SERVICE_FIELDTYPE_DOC_INFO: 483 case SW_SERVICE_FIELDTYPE_TEMPLATE_NAME: 484 case SW_SERVICE_FIELDTYPE_USER_EXT: 485 case SW_SERVICE_FIELDTYPE_REF_PAGE_SET: 486 case SW_SERVICE_FIELDTYPE_REF_PAGE_GET: 487 case SW_SERVICE_FIELDTYPE_JUMP_EDIT: 488 case SW_SERVICE_FIELDTYPE_SCRIPT: 489 case SW_SERVICE_FIELDTYPE_DATABASE_NEXT_SET: 490 case SW_SERVICE_FIELDTYPE_DATABASE_NUM_SET: 491 case SW_SERVICE_FIELDTYPE_DATABASE_SET_NUM: 492 case SW_SERVICE_FIELDTYPE_DATABASE: 493 case SW_SERVICE_FIELDTYPE_DATABASE_NAME: 494 case SW_SERVICE_FIELDTYPE_PAGE_COUNT : 495 case SW_SERVICE_FIELDTYPE_PARAGRAPH_COUNT : 496 case SW_SERVICE_FIELDTYPE_WORD_COUNT : 497 case SW_SERVICE_FIELDTYPE_CHARACTER_COUNT : 498 case SW_SERVICE_FIELDTYPE_TABLE_COUNT : 499 case SW_SERVICE_FIELDTYPE_GRAPHIC_OBJECT_COUNT : 500 case SW_SERVICE_FIELDTYPE_EMBEDDED_OBJECT_COUNT : 501 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_AUTHOR : 502 case SW_SERVICE_FIELDTYPE_DOCINFO_CHANGE_DATE_TIME : 503 case SW_SERVICE_FIELDTYPE_DOCINFO_EDIT_TIME : 504 case SW_SERVICE_FIELDTYPE_DOCINFO_DESCRIPTION : 505 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_AUTHOR : 506 case SW_SERVICE_FIELDTYPE_DOCINFO_CREATE_DATE_TIME : 507 case SW_SERVICE_FIELDTYPE_DOCINFO_CUSTOM : 508 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_AUTHOR : 509 case SW_SERVICE_FIELDTYPE_DOCINFO_PRINT_DATE_TIME : 510 case SW_SERVICE_FIELDTYPE_DOCINFO_KEY_WORDS : 511 case SW_SERVICE_FIELDTYPE_DOCINFO_SUBJECT : 512 case SW_SERVICE_FIELDTYPE_DOCINFO_TITLE : 513 case SW_SERVICE_FIELDTYPE_DOCINFO_REVISION : 514 case SW_SERVICE_FIELDTYPE_BIBLIOGRAPHY: 515 case SW_SERVICE_FIELDTYPE_INPUT_USER : 516 case SW_SERVICE_FIELDTYPE_HIDDEN_TEXT : 517 case SW_SERVICE_FIELDTYPE_COMBINED_CHARACTERS : 518 case SW_SERVICE_FIELDTYPE_DROPDOWN : 519 case SW_SERVICE_FIELDTYPE_TABLE_FORMULA: 520 xRet = (cppu::OWeakObject*)new SwXTextField(nObjectType); 521 break; 522 case SW_SERVICE_FIELDTYPE_ANNOTATION: 523 xRet = (cppu::OWeakObject*)new SwXTextField(nObjectType, pDoc); 524 break; 525 case SW_SERVICE_FIELDMASTER_USER: 526 case SW_SERVICE_FIELDMASTER_DDE: 527 case SW_SERVICE_FIELDMASTER_SET_EXP : 528 case SW_SERVICE_FIELDMASTER_DATABASE: 529 { 530 sal_uInt16 nResId = USHRT_MAX; 531 switch(nObjectType) 532 { 533 case SW_SERVICE_FIELDMASTER_USER: nResId = RES_USERFLD; break; 534 case SW_SERVICE_FIELDMASTER_DDE: nResId = RES_DDEFLD; break; 535 case SW_SERVICE_FIELDMASTER_SET_EXP : nResId = RES_SETEXPFLD; break; 536 case SW_SERVICE_FIELDMASTER_DATABASE: nResId = RES_DBFLD; break; 537 } 538 xRet = (cppu::OWeakObject*)new SwXFieldMaster(pDoc, nResId); 539 } 540 break; 541 case SW_SERVICE_FIELDMASTER_BIBLIOGRAPHY: 542 { 543 SwFieldType* pType = pDoc->GetFldType(RES_AUTHORITY, aEmptyStr, sal_True); 544 if(!pType) 545 { 546 SwAuthorityFieldType aType(pDoc); 547 pType = pDoc->InsertFldType(aType); 548 } 549 else 550 { 551 SwXFieldMaster* pMaster = SwIterator<SwXFieldMaster,SwFieldType>::FirstElement( *pType ); 552 if(pMaster) 553 xRet = (cppu::OWeakObject*)pMaster; 554 } 555 if(!xRet.is()) 556 xRet = (cppu::OWeakObject*)new SwXFieldMaster(*pType, pDoc); 557 } 558 break; 559 case SW_SERVICE_PARAGRAPH : 560 xRet = (cppu::OWeakObject*)new SwXParagraph(); 561 break; 562 case SW_SERVICE_NUMBERING_RULES : 563 xRet = (cppu::OWeakObject*)new SwXNumberingRules(*pDoc); 564 break; 565 case SW_SERVICE_TEXT_COLUMNS : 566 xRet = (cppu::OWeakObject*)new SwXTextColumns(0); 567 break; 568 case SW_SERVICE_DEFAULTS: 569 xRet = (cppu::OWeakObject*)new SwXTextDefaults( pDoc ); 570 break; 571 case SW_SERVICE_IMAP_RECTANGLE : 572 xRet = SvUnoImageMapRectangleObject_createInstance( lcl_GetSupportedMacroItems() ); 573 break; 574 case SW_SERVICE_IMAP_CIRCLE : 575 xRet = SvUnoImageMapCircleObject_createInstance( lcl_GetSupportedMacroItems() ); 576 break; 577 case SW_SERVICE_IMAP_POLYGON : 578 xRet = SvUnoImageMapPolygonObject_createInstance( lcl_GetSupportedMacroItems() ); 579 break; 580 case SW_SERVICE_CHART2_DATA_PROVIDER : 581 // #i64497# If a chart is in a temporary document during clipboard 582 // paste, there should be no data provider, so that own data is used 583 // This should not happen during copy/paste, as this will unlink 584 // charts using table data. 585 OSL_ASSERT( pDoc->GetDocShell()->GetCreateMode() != SFX_CREATE_MODE_EMBEDDED ); 586 if( pDoc->GetDocShell()->GetCreateMode() != SFX_CREATE_MODE_EMBEDDED ) 587 xRet = (cppu::OWeakObject*) pDoc->GetChartDataProvider( true /* create - if not yet available */ ); 588 break; 589 case SW_SERVICE_TYPE_META: 590 xRet = static_cast< ::cppu::OWeakObject* >( new SwXMeta(pDoc) ); 591 break; 592 case SW_SERVICE_FIELDTYPE_METAFIELD: 593 xRet = static_cast< ::cppu::OWeakObject* >(new SwXMetaField(pDoc)); 594 break; 595 default: 596 throw uno::RuntimeException(); 597 } 598 return xRet; 599 } 600 /****************************************************************** 601 * SwXTextTables 602 ******************************************************************/ 603 //SMART_UNO_IMPLEMENTATION( SwXTextTables, UsrObject ); 604 605 SwXTextTables::SwXTextTables(SwDoc* pDc) : 606 SwUnoCollection(pDc) 607 { 608 609 } 610 611 SwXTextTables::~SwXTextTables() 612 { 613 614 } 615 616 sal_Int32 SwXTextTables::getCount(void) 617 { 618 vos::OGuard aGuard(Application::GetSolarMutex()); 619 sal_Int32 nRet = 0; 620 if(IsValid()) 621 nRet = GetDoc()->GetTblFrmFmtCount(sal_True); 622 return nRet; 623 } 624 625 uno::Any SAL_CALL SwXTextTables::getByIndex(sal_Int32 nIndex) 626 { 627 vos::OGuard aGuard(Application::GetSolarMutex()); 628 uno::Any aRet; 629 if(IsValid()) 630 { 631 if(0 <= nIndex && GetDoc()->GetTblFrmFmtCount(sal_True) > nIndex) 632 { 633 SwFrmFmt& rFmt = GetDoc()->GetTblFrmFmt( static_cast< xub_StrLen >(nIndex), sal_True); 634 uno::Reference< XTextTable > xTbl = SwXTextTables::GetObject(rFmt); 635 aRet.setValue( &xTbl, 636 ::getCppuType((uno::Reference< XTextTable>*)0)); 637 } 638 else 639 throw IndexOutOfBoundsException(); 640 } 641 else 642 throw uno::RuntimeException(); 643 return aRet; 644 } 645 646 uno::Any SwXTextTables::getByName(const OUString& rItemName) 647 { 648 vos::OGuard aGuard(Application::GetSolarMutex()); 649 uno::Any aRet; 650 if(IsValid()) 651 { 652 sal_uInt16 nCount = GetDoc()->GetTblFrmFmtCount(sal_True); 653 uno::Reference< XTextTable > xTbl; 654 for( sal_uInt16 i = 0; i < nCount; i++) 655 { 656 String aName(rItemName); 657 SwFrmFmt& rFmt = GetDoc()->GetTblFrmFmt(i, sal_True); 658 if(aName == rFmt.GetName()) 659 { 660 xTbl = SwXTextTables::GetObject(rFmt); 661 aRet.setValue(&xTbl, 662 ::getCppuType(( uno::Reference< XTextTable >*)0)); 663 break; 664 } 665 } 666 if(!xTbl.is()) 667 throw NoSuchElementException(); 668 } 669 else 670 throw uno::RuntimeException(); 671 return aRet; 672 } 673 674 uno::Sequence< OUString > SwXTextTables::getElementNames(void) 675 { 676 vos::OGuard aGuard(Application::GetSolarMutex()); 677 if(!IsValid()) 678 throw uno::RuntimeException(); 679 sal_uInt16 nCount = GetDoc()->GetTblFrmFmtCount(sal_True); 680 uno::Sequence<OUString> aSeq(nCount); 681 if(nCount) 682 { 683 OUString* pArray = aSeq.getArray(); 684 for( sal_uInt16 i = 0; i < nCount; i++) 685 { 686 SwFrmFmt& rFmt = GetDoc()->GetTblFrmFmt(i, sal_True); 687 688 pArray[i] = OUString(rFmt.GetName()); 689 } 690 } 691 return aSeq; 692 } 693 694 sal_Bool SwXTextTables::hasByName(const OUString& rName) 695 { 696 vos::OGuard aGuard(Application::GetSolarMutex()); 697 sal_Bool bRet= sal_False; 698 if(IsValid()) 699 { 700 sal_uInt16 nCount = GetDoc()->GetTblFrmFmtCount(sal_True); 701 for( sal_uInt16 i = 0; i < nCount; i++) 702 { 703 String aName(rName); 704 SwFrmFmt& rFmt = GetDoc()->GetTblFrmFmt(i, sal_True); 705 if(aName == rFmt.GetName()) 706 { 707 bRet = sal_True; 708 break; 709 } 710 } 711 } 712 else 713 throw uno::RuntimeException(); 714 return bRet; 715 } 716 717 uno::Type SAL_CALL 718 SwXTextTables::getElementType( ) 719 { 720 return ::getCppuType((uno::Reference<XTextTable>*)0); 721 } 722 723 sal_Bool SwXTextTables::hasElements(void) 724 { 725 vos::OGuard aGuard(Application::GetSolarMutex()); 726 if(!IsValid()) 727 throw uno::RuntimeException(); 728 return 0 != GetDoc()->GetTblFrmFmtCount(sal_True); 729 } 730 731 OUString SwXTextTables::getImplementationName(void) 732 { 733 return C2U("SwXTextTables"); 734 } 735 736 sal_Bool SwXTextTables::supportsService(const OUString& rServiceName) 737 { 738 return rServiceName == C2U("com.sun.star.text.TextTables"); 739 } 740 741 uno::Sequence< OUString > SwXTextTables::getSupportedServiceNames(void) 742 { 743 uno::Sequence< OUString > aRet(1); 744 OUString* pArr = aRet.getArray(); 745 pArr[0] = C2U("com.sun.star.text.TextTables"); 746 return aRet; 747 } 748 749 XTextTable* SwXTextTables::GetObject( SwFrmFmt& rFmt ) 750 { 751 vos::OGuard aGuard(Application::GetSolarMutex()); 752 SwXTextTable* pTbl = SwIterator<SwXTextTable,SwFmt>::FirstElement( rFmt ); 753 if( !pTbl ) 754 pTbl = new SwXTextTable(rFmt); 755 return pTbl ; 756 } 757 758 759 /****************************************************************** 760 * SwXFrameEnumeration 761 ******************************************************************/ 762 namespace 763 { 764 template<FlyCntType T> struct UnoFrameWrap_traits {}; 765 766 template<> 767 struct UnoFrameWrap_traits<FLYCNTTYPE_FRM> 768 { 769 typedef SwXTextFrame core_frame_t; 770 typedef XTextFrame uno_frame_t; 771 static inline bool filter(const SwNode* const pNode) { return !pNode->IsNoTxtNode(); }; 772 }; 773 774 template<> 775 struct UnoFrameWrap_traits<FLYCNTTYPE_GRF> 776 { 777 typedef SwXTextGraphicObject core_frame_t; 778 typedef XTextContent uno_frame_t; 779 static inline bool filter(const SwNode* const pNode) { return pNode->IsGrfNode(); }; 780 }; 781 782 template<> 783 struct UnoFrameWrap_traits<FLYCNTTYPE_OLE> 784 { 785 typedef SwXTextEmbeddedObject core_frame_t; 786 typedef XEmbeddedObjectSupplier uno_frame_t; 787 static inline bool filter(const SwNode* const pNode) { return pNode->IsOLENode(); }; 788 }; 789 790 template<FlyCntType T> 791 static uno::Any lcl_UnoWrapFrame(SwFrmFmt* pFmt) 792 { 793 SwXFrame* pFrm = SwIterator<SwXFrame,SwFmt>::FirstElement( *pFmt ); 794 if(!pFrm) 795 pFrm = new typename UnoFrameWrap_traits<T>::core_frame_t(*pFmt); 796 Reference< typename UnoFrameWrap_traits<T>::uno_frame_t > xFrm = 797 static_cast< typename UnoFrameWrap_traits<T>::core_frame_t* >(pFrm); 798 return uno::makeAny(xFrm); 799 } 800 801 // runtime adapter for lcl_UnoWrapFrame 802 static uno::Any lcl_UnoWrapFrame(SwFrmFmt* pFmt, FlyCntType eType) throw(uno::RuntimeException()) 803 { 804 switch(eType) 805 { 806 case FLYCNTTYPE_FRM: 807 return lcl_UnoWrapFrame<FLYCNTTYPE_FRM>(pFmt); 808 case FLYCNTTYPE_GRF: 809 return lcl_UnoWrapFrame<FLYCNTTYPE_GRF>(pFmt); 810 case FLYCNTTYPE_OLE: 811 return lcl_UnoWrapFrame<FLYCNTTYPE_OLE>(pFmt); 812 default: 813 throw uno::RuntimeException(); 814 } 815 } 816 817 template<FlyCntType T> 818 class SwXFrameEnumeration 819 : public SwSimpleEnumeration_Base 820 { 821 private: 822 typedef ::std::list< Any > frmcontainer_t; 823 frmcontainer_t m_aFrames; 824 protected: 825 virtual ~SwXFrameEnumeration() {}; 826 public: 827 SwXFrameEnumeration(const SwDoc* const pDoc); 828 829 //XEnumeration 830 virtual sal_Bool SAL_CALL hasMoreElements(void); 831 virtual Any SAL_CALL nextElement(void); 832 833 //XServiceInfo 834 virtual OUString SAL_CALL getImplementationName(void); 835 virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName); 836 virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(void); 837 }; 838 } 839 840 template<FlyCntType T> 841 SwXFrameEnumeration<T>::SwXFrameEnumeration(const SwDoc* const pDoc) 842 : m_aFrames() 843 { 844 vos::OGuard aGuard(Application::GetSolarMutex()); 845 const SwSpzFrmFmts* const pFmts = pDoc->GetSpzFrmFmts(); 846 if(!pFmts->Count()) 847 return; 848 // --> OD 2009-09-10 #i104937# 849 // const SwFrmFmt* const pFmtsEnd = (*pFmts)[pFmts->Count()]; 850 const sal_uInt16 nSize = pFmts->Count(); 851 // <-- 852 ::std::insert_iterator<frmcontainer_t> pInserter = ::std::insert_iterator<frmcontainer_t>(m_aFrames, m_aFrames.begin()); 853 // --> OD 2009-09-10 #i104937# 854 SwFrmFmt* pFmt( 0 ); 855 for( sal_uInt16 i = 0; i < nSize; ++i ) 856 // for(SwFrmFmt* pFmt = (*pFmts)[0]; pFmt < pFmtsEnd; ++pFmt) 857 // <-- 858 { 859 // --> OD 2009-09-10 #i104937# 860 pFmt = (*pFmts)[i]; 861 // <-- 862 if(pFmt->Which() != RES_FLYFRMFMT) 863 continue; 864 const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx(); 865 if(!pIdx || !pIdx->GetNodes().IsDocNodes()) 866 continue; 867 const SwNode* pNd = pDoc->GetNodes()[ pIdx->GetIndex() + 1 ]; 868 if(UnoFrameWrap_traits<T>::filter(pNd)) 869 *pInserter++ = lcl_UnoWrapFrame<T>(pFmt); 870 } 871 } 872 873 template<FlyCntType T> 874 sal_Bool SwXFrameEnumeration<T>::hasMoreElements(void) 875 { 876 vos::OGuard aGuard(Application::GetSolarMutex()); 877 return !m_aFrames.empty(); 878 } 879 880 template<FlyCntType T> 881 Any SwXFrameEnumeration<T>::nextElement(void) 882 { 883 vos::OGuard aGuard(Application::GetSolarMutex()); 884 if(m_aFrames.empty()) 885 throw NoSuchElementException(); 886 Any aResult = *m_aFrames.begin(); 887 m_aFrames.pop_front(); 888 return aResult; 889 } 890 891 template<FlyCntType T> 892 OUString SwXFrameEnumeration<T>::getImplementationName(void) 893 { 894 return C2U("SwXFrameEnumeration"); 895 } 896 897 template<FlyCntType T> 898 sal_Bool SwXFrameEnumeration<T>::supportsService(const OUString& ServiceName) 899 { 900 return C2U("com.sun.star.container.XEnumeration") == ServiceName; 901 } 902 903 template<FlyCntType T> 904 Sequence< OUString > SwXFrameEnumeration<T>::getSupportedServiceNames(void) 905 { 906 return ::comphelper::makeSequence(C2U("com.sun.star.container.XEnumeration")); 907 } 908 909 /****************************************************************** 910 * SwXFrames 911 ******************************************************************/ 912 OUString SwXFrames::getImplementationName(void) 913 { 914 return C2U("SwXFrames"); 915 } 916 917 sal_Bool SwXFrames::supportsService(const OUString& rServiceName) 918 { 919 return C2U("com.sun.star.text.TextFrames") == rServiceName; 920 } 921 922 Sequence<OUString> SwXFrames::getSupportedServiceNames(void) 923 { 924 return ::comphelper::makeSequence(C2U("com.sun.star.text.TextFrames")); 925 } 926 927 SwXFrames::SwXFrames(SwDoc* _pDoc, FlyCntType eSet) : 928 SwUnoCollection(_pDoc), 929 eType(eSet) 930 {} 931 932 SwXFrames::~SwXFrames() 933 {} 934 935 uno::Reference<container::XEnumeration> SwXFrames::createEnumeration(void) 936 { 937 vos::OGuard aGuard(Application::GetSolarMutex()); 938 if(!IsValid()) 939 throw uno::RuntimeException(); 940 switch(eType) 941 { 942 case FLYCNTTYPE_FRM: 943 return uno::Reference< container::XEnumeration >( 944 new SwXFrameEnumeration<FLYCNTTYPE_FRM>(GetDoc())); 945 case FLYCNTTYPE_GRF: 946 return uno::Reference< container::XEnumeration >( 947 new SwXFrameEnumeration<FLYCNTTYPE_GRF>(GetDoc())); 948 case FLYCNTTYPE_OLE: 949 return uno::Reference< container::XEnumeration >( 950 new SwXFrameEnumeration<FLYCNTTYPE_OLE>(GetDoc())); 951 default: 952 throw uno::RuntimeException(); 953 } 954 } 955 956 sal_Int32 SwXFrames::getCount(void) 957 { 958 vos::OGuard aGuard(Application::GetSolarMutex()); 959 if(!IsValid()) 960 throw uno::RuntimeException(); 961 return GetDoc()->GetFlyCount(eType); 962 } 963 964 uno::Any SwXFrames::getByIndex(sal_Int32 nIndex) 965 { 966 vos::OGuard aGuard(Application::GetSolarMutex()); 967 if(!IsValid()) 968 throw uno::RuntimeException(); 969 if(nIndex < 0 || nIndex >= USHRT_MAX) 970 throw IndexOutOfBoundsException(); 971 SwFrmFmt* pFmt = GetDoc()->GetFlyNum(static_cast<sal_uInt16>(nIndex), eType); 972 if(!pFmt) 973 throw IndexOutOfBoundsException(); 974 return lcl_UnoWrapFrame(pFmt, eType); 975 } 976 977 uno::Any SwXFrames::getByName(const OUString& rName) 978 { 979 vos::OGuard aGuard(Application::GetSolarMutex()); 980 if(!IsValid()) 981 throw uno::RuntimeException(); 982 const SwFrmFmt* pFmt; 983 switch(eType) 984 { 985 case FLYCNTTYPE_GRF: 986 pFmt = GetDoc()->FindFlyByName(rName, ND_GRFNODE); 987 break; 988 case FLYCNTTYPE_OLE: 989 pFmt = GetDoc()->FindFlyByName(rName, ND_OLENODE); 990 break; 991 default: 992 pFmt = GetDoc()->FindFlyByName(rName, ND_TEXTNODE); 993 break; 994 } 995 if(!pFmt) 996 throw NoSuchElementException(); 997 return lcl_UnoWrapFrame(const_cast<SwFrmFmt*>(pFmt), eType); 998 } 999 1000 uno::Sequence<OUString> SwXFrames::getElementNames(void) 1001 { 1002 vos::OGuard aGuard(Application::GetSolarMutex()); 1003 if(!IsValid()) 1004 throw uno::RuntimeException(); 1005 const Reference<XEnumeration> xEnum = createEnumeration(); 1006 ::std::vector<OUString> vNames; 1007 while(xEnum->hasMoreElements()) 1008 { 1009 Reference<container::XNamed> xNamed; 1010 xEnum->nextElement() >>= xNamed; 1011 if(xNamed.is()) 1012 vNames.push_back(xNamed->getName()); 1013 } 1014 return ::comphelper::containerToSequence(vNames); 1015 } 1016 1017 sal_Bool SwXFrames::hasByName(const OUString& rName) 1018 { 1019 vos::OGuard aGuard(Application::GetSolarMutex()); 1020 if(!IsValid()) 1021 throw uno::RuntimeException(); 1022 switch(eType) 1023 { 1024 case FLYCNTTYPE_GRF: 1025 return GetDoc()->FindFlyByName(rName, ND_GRFNODE) != NULL; 1026 case FLYCNTTYPE_OLE: 1027 return GetDoc()->FindFlyByName(rName, ND_OLENODE) != NULL; 1028 default: 1029 return GetDoc()->FindFlyByName(rName, ND_TEXTNODE) != NULL; 1030 } 1031 } 1032 1033 uno::Type SAL_CALL SwXFrames::getElementType() 1034 { 1035 vos::OGuard aGuard(Application::GetSolarMutex()); 1036 switch(eType) 1037 { 1038 case FLYCNTTYPE_FRM: 1039 return ::getCppuType((uno::Reference<XTextFrame>*)0); 1040 case FLYCNTTYPE_GRF: 1041 return ::getCppuType((uno::Reference<XTextContent>*)0); 1042 case FLYCNTTYPE_OLE: 1043 return ::getCppuType((uno::Reference<XEmbeddedObjectSupplier>*)0); 1044 default: 1045 return uno::Type(); 1046 } 1047 } 1048 1049 sal_Bool SwXFrames::hasElements(void) 1050 { 1051 vos::OGuard aGuard(Application::GetSolarMutex()); 1052 if(!IsValid()) 1053 throw uno::RuntimeException(); 1054 return GetDoc()->GetFlyCount(eType) > 0; 1055 } 1056 1057 SwXFrame* SwXFrames::GetObject(SwFrmFmt& rFmt, FlyCntType eType) 1058 { 1059 SwXFrame* pFrm = SwIterator<SwXFrame,SwFmt>::FirstElement( rFmt ); 1060 if(pFrm) return pFrm; 1061 switch(eType) 1062 { 1063 case FLYCNTTYPE_FRM: 1064 return new SwXTextFrame(rFmt); 1065 case FLYCNTTYPE_GRF: 1066 return new SwXTextGraphicObject(rFmt); 1067 case FLYCNTTYPE_OLE: 1068 return new SwXTextEmbeddedObject(rFmt); 1069 default: 1070 return NULL; 1071 } 1072 } 1073 1074 /****************************************************************** 1075 * SwXTextFrames 1076 ******************************************************************/ 1077 OUString SwXTextFrames::getImplementationName(void) 1078 { 1079 return C2U("SwXTextFrames"); 1080 } 1081 1082 sal_Bool SwXTextFrames::supportsService(const OUString& rServiceName) 1083 { 1084 return C2U("com.sun.star.text.TextFrames") == rServiceName; 1085 } 1086 1087 Sequence< OUString > SwXTextFrames::getSupportedServiceNames(void) 1088 { 1089 Sequence< OUString > aRet(1); 1090 OUString* pArray = aRet.getArray(); 1091 pArray[0] = C2U("com.sun.star.text.TextFrames"); 1092 return aRet; 1093 } 1094 1095 SwXTextFrames::SwXTextFrames(SwDoc* _pDoc) : 1096 SwXFrames(_pDoc, FLYCNTTYPE_FRM) 1097 { 1098 } 1099 1100 SwXTextFrames::~SwXTextFrames() 1101 { 1102 } 1103 1104 /****************************************************************** 1105 * SwXTextGraphicObjects 1106 ******************************************************************/ 1107 1108 OUString SwXTextGraphicObjects::getImplementationName(void) 1109 { 1110 return C2U("SwXTextGraphicObjects"); 1111 } 1112 1113 sal_Bool SwXTextGraphicObjects::supportsService(const OUString& rServiceName) 1114 { 1115 return C2U("com.sun.star.text.TextGraphicObjects") == rServiceName; 1116 } 1117 1118 Sequence< OUString > SwXTextGraphicObjects::getSupportedServiceNames(void) 1119 { 1120 Sequence< OUString > aRet(1); 1121 OUString* pArray = aRet.getArray(); 1122 pArray[0] = C2U("com.sun.star.text.TextGraphicObjects"); 1123 return aRet; 1124 } 1125 1126 SwXTextGraphicObjects::SwXTextGraphicObjects(SwDoc* _pDoc) : 1127 SwXFrames(_pDoc, FLYCNTTYPE_GRF) 1128 { 1129 } 1130 1131 SwXTextGraphicObjects::~SwXTextGraphicObjects() 1132 { 1133 } 1134 1135 /****************************************************************** 1136 * SwXTextEmbeddedObjects 1137 ******************************************************************/ 1138 OUString SwXTextEmbeddedObjects::getImplementationName(void) 1139 { 1140 return C2U("SwXTextEmbeddedObjects"); 1141 } 1142 1143 sal_Bool SwXTextEmbeddedObjects::supportsService(const OUString& rServiceName) 1144 { 1145 return C2U("com.sun.star.text.TextEmbeddedObjects") == rServiceName; 1146 } 1147 1148 Sequence< OUString > SwXTextEmbeddedObjects::getSupportedServiceNames(void) 1149 { 1150 Sequence< OUString > aRet(1); 1151 OUString* pArray = aRet.getArray(); 1152 pArray[0] = C2U("com.sun.star.text.TextEmbeddedObjects"); 1153 return aRet; 1154 } 1155 1156 SwXTextEmbeddedObjects::SwXTextEmbeddedObjects(SwDoc* _pDoc) : 1157 SwXFrames(_pDoc, FLYCNTTYPE_OLE) 1158 { 1159 } 1160 1161 SwXTextEmbeddedObjects::~SwXTextEmbeddedObjects() 1162 { 1163 } 1164 1165 /****************************************************************** 1166 * 1167 ******************************************************************/ 1168 #define PASSWORD_STD_TIMEOUT 1000 1169 OUString SwXTextSections::getImplementationName(void) 1170 { 1171 return C2U("SwXTextSections"); 1172 } 1173 1174 sal_Bool SwXTextSections::supportsService(const OUString& rServiceName) 1175 { 1176 return C2U("com.sun.star.text.TextSections") == rServiceName; 1177 } 1178 1179 Sequence< OUString > SwXTextSections::getSupportedServiceNames(void) 1180 { 1181 Sequence< OUString > aRet(1); 1182 OUString* pArray = aRet.getArray(); 1183 pArray[0] = C2U("com.sun.star.text.TextSections"); 1184 return aRet; 1185 } 1186 1187 SwXTextSections::SwXTextSections(SwDoc* _pDoc) : 1188 SwUnoCollection(_pDoc) 1189 { 1190 } 1191 1192 SwXTextSections::~SwXTextSections() 1193 { 1194 } 1195 1196 sal_Int32 SwXTextSections::getCount(void) 1197 { 1198 vos::OGuard aGuard(Application::GetSolarMutex()); 1199 if(!IsValid()) 1200 throw uno::RuntimeException(); 1201 const SwSectionFmts& rSectFmts = GetDoc()->GetSections(); 1202 sal_uInt16 nCount = rSectFmts.Count(); 1203 for(sal_uInt16 i = nCount; i; i--) 1204 { 1205 if( !rSectFmts[i - 1]->IsInNodesArr()) 1206 nCount--; 1207 } 1208 return nCount; 1209 } 1210 1211 uno::Any SwXTextSections::getByIndex(sal_Int32 nIndex) 1212 { 1213 vos::OGuard aGuard(Application::GetSolarMutex()); 1214 uno::Reference< XTextSection > xRet; 1215 if(IsValid()) 1216 { 1217 SwSectionFmts& rFmts = GetDoc()->GetSections(); 1218 1219 const SwSectionFmts& rSectFmts = GetDoc()->GetSections(); 1220 sal_uInt16 nCount = rSectFmts.Count(); 1221 for(sal_uInt16 i = 0; i < nCount; i++) 1222 { 1223 if( !rSectFmts[i]->IsInNodesArr()) 1224 nIndex ++; 1225 else if(nIndex == i) 1226 break; 1227 if(nIndex == i) 1228 break; 1229 } 1230 if(nIndex >= 0 && nIndex < rFmts.Count()) 1231 { 1232 SwSectionFmt* pFmt = rFmts[(sal_uInt16)nIndex]; 1233 xRet = GetObject(*pFmt); 1234 } 1235 else 1236 throw IndexOutOfBoundsException(); 1237 } 1238 else 1239 throw uno::RuntimeException(); 1240 return makeAny(xRet); 1241 } 1242 1243 uno::Any SwXTextSections::getByName(const OUString& Name) 1244 { 1245 vos::OGuard aGuard(Application::GetSolarMutex()); 1246 uno::Any aRet; 1247 if(IsValid()) 1248 { 1249 String aName(Name); 1250 SwSectionFmts& rFmts = GetDoc()->GetSections(); 1251 uno::Reference< XTextSection > xSect; 1252 for(sal_uInt16 i = 0; i < rFmts.Count(); i++) 1253 { 1254 SwSectionFmt* pFmt = rFmts[i]; 1255 if (pFmt->IsInNodesArr() 1256 && (aName == pFmt->GetSection()->GetSectionName())) 1257 { 1258 xSect = GetObject(*pFmt); 1259 aRet.setValue(&xSect, ::getCppuType((uno::Reference<XTextSection>*)0)); 1260 break; 1261 } 1262 } 1263 if(!xSect.is()) 1264 throw NoSuchElementException(); 1265 } 1266 else 1267 throw uno::RuntimeException(); 1268 return aRet; 1269 } 1270 1271 uno::Sequence< OUString > SwXTextSections::getElementNames(void) 1272 { 1273 vos::OGuard aGuard(Application::GetSolarMutex()); 1274 if(!IsValid()) 1275 throw uno::RuntimeException(); 1276 sal_uInt16 nCount = GetDoc()->GetSections().Count(); 1277 SwSectionFmts& rSectFmts = GetDoc()->GetSections(); 1278 for(sal_uInt16 i = nCount; i; i--) 1279 { 1280 if( !rSectFmts[i - 1]->IsInNodesArr()) 1281 nCount--; 1282 } 1283 1284 uno::Sequence<OUString> aSeq(nCount); 1285 if(nCount) 1286 { 1287 SwSectionFmts& rFmts = GetDoc()->GetSections(); 1288 OUString* pArray = aSeq.getArray(); 1289 sal_uInt16 nIndex = 0; 1290 for( sal_uInt16 i = 0; i < nCount; i++, nIndex++) 1291 { 1292 const SwSectionFmt* pFmt = rFmts[nIndex]; 1293 while(!pFmt->IsInNodesArr()) 1294 { 1295 pFmt = rFmts[++nIndex]; 1296 } 1297 pArray[i] = pFmt->GetSection()->GetSectionName(); 1298 } 1299 } 1300 return aSeq; 1301 } 1302 1303 sal_Bool SwXTextSections::hasByName(const OUString& Name) 1304 { 1305 vos::OGuard aGuard(Application::GetSolarMutex()); 1306 sal_Bool bRet = sal_False; 1307 String aName(Name); 1308 if(IsValid()) 1309 { 1310 SwSectionFmts& rFmts = GetDoc()->GetSections(); 1311 for(sal_uInt16 i = 0; i < rFmts.Count(); i++) 1312 { 1313 const SwSectionFmt* pFmt = rFmts[i]; 1314 if (aName == pFmt->GetSection()->GetSectionName()) 1315 { 1316 bRet = sal_True; 1317 break; 1318 } 1319 } 1320 } 1321 else 1322 { 1323 //Sonderbehandlung der dbg_ - Methoden 1324 if( COMPARE_EQUAL != aName.CompareToAscii("dbg_", 4)) 1325 throw uno::RuntimeException(); 1326 } 1327 return bRet; 1328 } 1329 1330 uno::Type SAL_CALL SwXTextSections::getElementType() 1331 { 1332 return ::getCppuType((uno::Reference<XTextSection>*)0); 1333 } 1334 1335 sal_Bool SwXTextSections::hasElements(void) 1336 { 1337 vos::OGuard aGuard(Application::GetSolarMutex()); 1338 sal_uInt16 nCount = 0; 1339 if(IsValid()) 1340 { 1341 SwSectionFmts& rFmts = GetDoc()->GetSections(); 1342 nCount = rFmts.Count(); 1343 } 1344 else 1345 throw uno::RuntimeException(); 1346 return nCount > 0; 1347 } 1348 1349 uno::Reference< XTextSection > SwXTextSections::GetObject( SwSectionFmt& rFmt ) 1350 { 1351 return SwXTextSection::CreateXTextSection(&rFmt); 1352 } 1353 1354 OUString SwXBookmarks::getImplementationName(void) 1355 { 1356 return OUString::createFromAscii("SwXBookmarks"); 1357 } 1358 1359 sal_Bool SwXBookmarks::supportsService(const OUString& rServiceName) 1360 { 1361 return OUString::createFromAscii("com.sun.star.text.Bookmarks") == rServiceName; 1362 } 1363 1364 Sequence< OUString > SwXBookmarks::getSupportedServiceNames(void) 1365 { 1366 Sequence< OUString > aRet(1); 1367 aRet[0] = OUString::createFromAscii("com.sun.star.text.Bookmarks"); 1368 return aRet; 1369 } 1370 1371 SwXBookmarks::SwXBookmarks(SwDoc* _pDoc) : 1372 SwUnoCollection(_pDoc) 1373 { } 1374 1375 SwXBookmarks::~SwXBookmarks() 1376 { } 1377 1378 sal_Int32 SwXBookmarks::getCount(void) 1379 { 1380 vos::OGuard aGuard(Application::GetSolarMutex()); 1381 if(!IsValid()) 1382 throw uno::RuntimeException(); 1383 return GetDoc()->getIDocumentMarkAccess()->getBookmarksCount(); 1384 } 1385 1386 uno::Any SwXBookmarks::getByIndex(sal_Int32 nIndex) 1387 { 1388 vos::OGuard aGuard(Application::GetSolarMutex()); 1389 if(!IsValid()) 1390 throw uno::RuntimeException(); 1391 IDocumentMarkAccess* const pMarkAccess = GetDoc()->getIDocumentMarkAccess(); 1392 if(nIndex < 0 || nIndex >= pMarkAccess->getBookmarksCount()) 1393 throw IndexOutOfBoundsException(); 1394 1395 uno::Any aRet; 1396 ::sw::mark::IMark* pBkmk = pMarkAccess->getBookmarksBegin()[nIndex].get(); 1397 const uno::Reference< text::XTextContent > xRef = 1398 SwXBookmark::CreateXBookmark(*GetDoc(), *pBkmk); 1399 aRet <<= xRef; 1400 return aRet; 1401 } 1402 1403 uno::Any SwXBookmarks::getByName(const rtl::OUString& rName) 1404 { 1405 vos::OGuard aGuard(Application::GetSolarMutex()); 1406 if(!IsValid()) 1407 throw uno::RuntimeException(); 1408 1409 IDocumentMarkAccess* const pMarkAccess = GetDoc()->getIDocumentMarkAccess(); 1410 IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->findBookmark(rName); 1411 if(ppBkmk == pMarkAccess->getBookmarksEnd()) 1412 throw NoSuchElementException(); 1413 1414 uno::Any aRet; 1415 const uno::Reference< text::XTextContent > xRef = 1416 SwXBookmark::CreateXBookmark(*GetDoc(), *(ppBkmk->get())); 1417 aRet <<= xRef; 1418 return aRet; 1419 } 1420 1421 uno::Sequence< OUString > SwXBookmarks::getElementNames(void) 1422 { 1423 vos::OGuard aGuard(Application::GetSolarMutex()); 1424 if(!IsValid()) 1425 throw uno::RuntimeException(); 1426 1427 IDocumentMarkAccess* const pMarkAccess = GetDoc()->getIDocumentMarkAccess(); 1428 uno::Sequence<OUString> aSeq(pMarkAccess->getBookmarksCount()); 1429 sal_Int32 nCnt = 0; 1430 for(IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getBookmarksBegin(); 1431 ppMark != pMarkAccess->getBookmarksEnd();) 1432 aSeq[nCnt++] = (*ppMark++)->GetName(); 1433 return aSeq; 1434 } 1435 1436 sal_Bool SwXBookmarks::hasByName(const OUString& rName) 1437 { 1438 vos::OGuard aGuard(Application::GetSolarMutex()); 1439 if(!IsValid()) 1440 throw uno::RuntimeException(); 1441 1442 IDocumentMarkAccess* const pMarkAccess = GetDoc()->getIDocumentMarkAccess(); 1443 return pMarkAccess->findBookmark(rName) != pMarkAccess->getBookmarksEnd(); 1444 } 1445 1446 uno::Type SAL_CALL SwXBookmarks::getElementType() 1447 { 1448 return ::getCppuType((uno::Reference<XTextContent>*)0); 1449 } 1450 1451 sal_Bool SwXBookmarks::hasElements(void) 1452 { 1453 vos::OGuard aGuard(Application::GetSolarMutex()); 1454 if(!IsValid()) 1455 throw uno::RuntimeException(); 1456 return GetDoc()->getIDocumentMarkAccess()->getBookmarksCount() != 0; 1457 } 1458 1459 /****************************************************************** 1460 * 1461 ******************************************************************/ 1462 1463 SwXNumberingRulesCollection::SwXNumberingRulesCollection( SwDoc* _pDoc ) : 1464 SwUnoCollection(_pDoc) 1465 { 1466 } 1467 1468 SwXNumberingRulesCollection::~SwXNumberingRulesCollection() 1469 { 1470 } 1471 1472 sal_Int32 SwXNumberingRulesCollection::getCount(void) 1473 { 1474 vos::OGuard aGuard(Application::GetSolarMutex()); 1475 if(!IsValid()) 1476 throw uno::RuntimeException(); 1477 return GetDoc()->GetNumRuleTbl().Count(); 1478 } 1479 1480 uno::Any SwXNumberingRulesCollection::getByIndex(sal_Int32 nIndex) 1481 { 1482 vos::OGuard aGuard(Application::GetSolarMutex()); 1483 uno::Any aRet; 1484 if(IsValid()) 1485 { 1486 uno::Reference< XIndexReplace > xRef; 1487 if ( nIndex < GetDoc()->GetNumRuleTbl().Count() ) 1488 { 1489 xRef = new SwXNumberingRules( *GetDoc()->GetNumRuleTbl()[ static_cast< sal_uInt16 >(nIndex) ] ); 1490 aRet.setValue(&xRef, ::getCppuType((uno::Reference<XIndexReplace>*)0)); 1491 } 1492 1493 if(!xRef.is()) 1494 throw IndexOutOfBoundsException(); 1495 } 1496 else 1497 throw uno::RuntimeException(); 1498 return aRet; 1499 } 1500 1501 uno::Type SAL_CALL SwXNumberingRulesCollection::getElementType() 1502 { 1503 return ::getCppuType((uno::Reference<XIndexReplace>*)0); 1504 } 1505 1506 sal_Bool SwXNumberingRulesCollection::hasElements(void) 1507 { 1508 vos::OGuard aGuard(Application::GetSolarMutex()); 1509 if(!IsValid()) 1510 throw uno::RuntimeException(); 1511 return GetDoc()->GetNumRuleTbl().Count() > 0; 1512 } 1513 1514 OUString SwXFootnotes::getImplementationName(void) 1515 { 1516 return C2U("SwXFootnotes"); 1517 } 1518 1519 sal_Bool SwXFootnotes::supportsService(const OUString& rServiceName) 1520 { 1521 return C2U("com.sun.star.text.Footnotes") == rServiceName; 1522 } 1523 1524 Sequence< OUString > SwXFootnotes::getSupportedServiceNames(void) 1525 { 1526 Sequence< OUString > aRet(1); 1527 OUString* pArray = aRet.getArray(); 1528 pArray[0] = C2U("com.sun.star.text.Footnotes"); 1529 return aRet; 1530 } 1531 1532 SwXFootnotes::SwXFootnotes(sal_Bool bEnd, SwDoc* _pDoc) 1533 : SwUnoCollection(_pDoc) 1534 , m_bEndnote(bEnd) 1535 { 1536 } 1537 1538 SwXFootnotes::~SwXFootnotes() 1539 { 1540 } 1541 1542 sal_Int32 SwXFootnotes::getCount(void) 1543 { 1544 vos::OGuard aGuard(Application::GetSolarMutex()); 1545 if(!IsValid()) 1546 throw uno::RuntimeException(); 1547 sal_Int32 nCount = 0; 1548 sal_uInt16 n, nFtnCnt = GetDoc()->GetFtnIdxs().Count(); 1549 SwTxtFtn* pTxtFtn; 1550 for( n = 0; n < nFtnCnt; ++n ) 1551 { 1552 pTxtFtn = GetDoc()->GetFtnIdxs()[ n ]; 1553 const SwFmtFtn& rFtn = pTxtFtn->GetFtn(); 1554 if ( rFtn.IsEndNote() != m_bEndnote ) 1555 continue; 1556 nCount++; 1557 } 1558 return nCount; 1559 } 1560 1561 uno::Any SwXFootnotes::getByIndex(sal_Int32 nIndex) 1562 { 1563 vos::OGuard aGuard(Application::GetSolarMutex()); 1564 uno::Any aRet; 1565 sal_Int32 nCount = 0; 1566 if(IsValid()) 1567 { 1568 sal_uInt16 n, nFtnCnt = GetDoc()->GetFtnIdxs().Count(); 1569 SwTxtFtn* pTxtFtn; 1570 uno::Reference< XFootnote > xRef; 1571 for( n = 0; n < nFtnCnt; ++n ) 1572 { 1573 pTxtFtn = GetDoc()->GetFtnIdxs()[ n ]; 1574 const SwFmtFtn& rFtn = pTxtFtn->GetFtn(); 1575 if ( rFtn.IsEndNote() != m_bEndnote ) 1576 continue; 1577 1578 if(nCount == nIndex) 1579 { 1580 xRef = SwXFootnote::CreateXFootnote(*GetDoc(), rFtn); 1581 aRet <<= xRef; 1582 break; 1583 } 1584 nCount++; 1585 } 1586 if(!xRef.is()) 1587 throw IndexOutOfBoundsException(); 1588 } 1589 else 1590 throw uno::RuntimeException(); 1591 return aRet; 1592 } 1593 1594 uno::Type SAL_CALL SwXFootnotes::getElementType() 1595 { 1596 return ::getCppuType((uno::Reference<XFootnote>*)0); 1597 } 1598 1599 sal_Bool SwXFootnotes::hasElements(void) 1600 { 1601 vos::OGuard aGuard(Application::GetSolarMutex()); 1602 if(!IsValid()) 1603 throw uno::RuntimeException(); 1604 return GetDoc()->GetFtnIdxs().Count() > 0; 1605 } 1606 1607 Reference<XFootnote> SwXFootnotes::GetObject( SwDoc& rDoc, const SwFmtFtn& rFmt ) 1608 { 1609 return SwXFootnote::CreateXFootnote(rDoc, rFmt); 1610 } 1611 1612 /****************************************************************** 1613 * 1614 ******************************************************************/ 1615 1616 OUString SwXReferenceMarks::getImplementationName(void) 1617 { 1618 return C2U("SwXReferenceMarks"); 1619 } 1620 1621 sal_Bool SwXReferenceMarks::supportsService(const OUString& rServiceName) 1622 { 1623 return C2U("com.sun.star.text.ReferenceMarks") == rServiceName; 1624 } 1625 1626 Sequence< OUString > SwXReferenceMarks::getSupportedServiceNames(void) 1627 { 1628 Sequence< OUString > aRet(1); 1629 OUString* pArray = aRet.getArray(); 1630 pArray[0] = C2U("com.sun.star.text.ReferenceMarks"); 1631 return aRet; 1632 } 1633 1634 SwXReferenceMarks::SwXReferenceMarks(SwDoc* _pDoc) : 1635 SwUnoCollection(_pDoc) 1636 { 1637 } 1638 1639 SwXReferenceMarks::~SwXReferenceMarks() 1640 { 1641 } 1642 1643 sal_Int32 SwXReferenceMarks::getCount(void) 1644 { 1645 vos::OGuard aGuard(Application::GetSolarMutex()); 1646 if(!IsValid()) 1647 throw uno::RuntimeException(); 1648 return GetDoc()->GetRefMarks(); 1649 } 1650 1651 uno::Any SwXReferenceMarks::getByIndex(sal_Int32 nIndex) 1652 { 1653 vos::OGuard aGuard(Application::GetSolarMutex()); 1654 uno::Any aRet; 1655 if(!IsValid()) 1656 throw uno::RuntimeException(); 1657 uno::Reference< XTextContent > xRef; 1658 if(0 <= nIndex && nIndex < USHRT_MAX) 1659 { 1660 const SwFmtRefMark* pMark = GetDoc()->GetRefMark( (sal_uInt16) nIndex ); 1661 if(pMark) 1662 { 1663 xRef = SwXReferenceMarks::GetObject( GetDoc(), pMark ); 1664 aRet.setValue(&xRef, ::getCppuType((uno::Reference<XTextContent>*)0)); 1665 } 1666 } 1667 if(!xRef.is()) 1668 throw IndexOutOfBoundsException(); 1669 return aRet; 1670 } 1671 1672 uno::Any SwXReferenceMarks::getByName(const OUString& rName) 1673 { 1674 vos::OGuard aGuard(Application::GetSolarMutex()); 1675 uno::Any aRet; 1676 if(IsValid()) 1677 { 1678 const SwFmtRefMark* pMark = GetDoc()->GetRefMark(rName); 1679 if(pMark) 1680 { 1681 uno::Reference< XTextContent > xRef = SwXReferenceMarks::GetObject( GetDoc(), pMark ); 1682 aRet.setValue(&xRef, ::getCppuType((uno::Reference<XTextContent>*)0)); 1683 } 1684 else 1685 throw NoSuchElementException(); 1686 } 1687 else 1688 throw uno::RuntimeException(); 1689 return aRet; 1690 } 1691 1692 uno::Sequence< OUString > SwXReferenceMarks::getElementNames(void) 1693 { 1694 vos::OGuard aGuard(Application::GetSolarMutex()); 1695 uno::Sequence<OUString> aRet; 1696 if(IsValid()) 1697 { 1698 SvStringsDtor aStrings; 1699 sal_uInt16 nCount = GetDoc()->GetRefMarks( &aStrings ); 1700 aRet.realloc(nCount); 1701 OUString* pNames = aRet.getArray(); 1702 for(sal_uInt16 i = 0; i < nCount; i++) 1703 pNames[i] = *aStrings.GetObject(i); 1704 } 1705 else 1706 throw uno::RuntimeException(); 1707 return aRet; 1708 } 1709 1710 sal_Bool SwXReferenceMarks::hasByName(const OUString& rName) 1711 { 1712 vos::OGuard aGuard(Application::GetSolarMutex()); 1713 if(!IsValid()) 1714 throw uno::RuntimeException(); 1715 return 0 != GetDoc()->GetRefMark( rName); 1716 } 1717 1718 uno::Type SAL_CALL SwXReferenceMarks::getElementType() 1719 { 1720 return ::getCppuType((uno::Reference<XTextContent>*)0); 1721 } 1722 1723 sal_Bool SwXReferenceMarks::hasElements(void) 1724 { 1725 vos::OGuard aGuard(Application::GetSolarMutex()); 1726 if(!IsValid()) 1727 throw uno::RuntimeException(); 1728 return 0 != GetDoc()->GetRefMarks(); 1729 } 1730 1731 SwXReferenceMark* SwXReferenceMarks::GetObject( SwDoc* pDoc, const SwFmtRefMark* pMark ) 1732 { 1733 vos::OGuard aGuard(Application::GetSolarMutex()); 1734 1735 return SwXReferenceMark::CreateXReferenceMark(*pDoc, *pMark); 1736 } 1737 1738 /****************************************************************** 1739 * 1740 ******************************************************************/ 1741 1742 void SwUnoCollection::Invalidate() 1743 { 1744 bObjectValid = sal_False; 1745 pDoc = 0; 1746 } 1747 1748 /* vim: set noet sw=4 ts=4: */ 1749