LCOV - code coverage report
Current view: top level - libreoffice/xmloff/source/forms - formenums.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 35 42 83.3 %
Date: 2012-12-27 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "formenums.hxx"
      21             : #include <osl/diagnose.h>
      22             : #include <com/sun/star/form/FormSubmitEncoding.hpp>
      23             : #include <com/sun/star/form/FormSubmitMethod.hpp>
      24             : #include <com/sun/star/sdb/CommandType.hpp>
      25             : #include <com/sun/star/form/NavigationBarMode.hpp>
      26             : #include <com/sun/star/form/TabulatorCycle.hpp>
      27             : #include <com/sun/star/form/FormButtonType.hpp>
      28             : #include <com/sun/star/form/ListSourceType.hpp>
      29             : #include <com/sun/star/awt/TextAlign.hpp>
      30             : #include <com/sun/star/awt/FontWidth.hpp>
      31             : #include <com/sun/star/awt/FontEmphasisMark.hpp>
      32             : #include <com/sun/star/awt/FontRelief.hpp>
      33             : #include <com/sun/star/awt/ScrollBarOrientation.hpp>
      34             : #include <com/sun/star/awt/VisualEffect.hpp>
      35             : #include <com/sun/star/awt/ImageScaleMode.hpp>
      36             : #include <tools/wintypes.hxx>       // for check states
      37             : #include <xmloff/xmltoken.hxx>
      38             : 
      39             : //.........................................................................
      40             : namespace xmloff
      41             : {
      42             : //.........................................................................
      43             : 
      44             :     using namespace ::com::sun::star::form;
      45             :     using namespace ::com::sun::star::sdb;
      46             :     using namespace ::com::sun::star::awt;
      47             :     using namespace ::com::sun::star;
      48             :     using namespace ::xmloff::token;
      49             : 
      50             :     const SvXMLEnumMapEntry*    OEnumMapper::s_pEnumMap[OEnumMapper::KNOWN_ENUM_PROPERTIES] =
      51             :     {
      52             :         NULL,
      53             :         NULL,
      54             :         NULL,
      55             :         NULL,
      56             :         NULL,
      57             :         NULL,
      58             :         NULL,
      59             :         NULL,
      60             :         NULL,
      61             :         NULL,
      62             :         NULL,
      63             :         NULL,
      64             :         NULL,
      65             :         NULL,
      66             :         NULL
      67             :     };
      68             : 
      69             :     //---------------------------------------------------------------------
      70        1025 :     const SvXMLEnumMapEntry*    OEnumMapper::getEnumMap(EnumProperties _eProperty)
      71             :     {
      72             :         OSL_ENSURE(_eProperty < KNOWN_ENUM_PROPERTIES, "OEnumMapper::getEnumMap: invalid index (this will crash)!");
      73             : 
      74        1025 :         const SvXMLEnumMapEntry*& rReturn = s_pEnumMap[_eProperty];
      75        1025 :         if (!rReturn)
      76             :         {
      77             :             // the map for this property is not initialized yet
      78         117 :              switch (_eProperty)
      79             :             {
      80             :                 // FormSubmitEncoding
      81             :                 case epSubmitEncoding:
      82             :                 {
      83             :                     static SvXMLEnumMapEntry aSubmitEncodingMap[] =
      84             :                     {
      85             :                         { XML_APPLICATION_X_WWW_FORM_URLENCODED, FormSubmitEncoding_URL },
      86             :                         { XML_MULTIPART_FORMDATA, FormSubmitEncoding_MULTIPART },
      87             :                         { XML_APPLICATION_TEXT, FormSubmitEncoding_TEXT },
      88             :                         { XML_TOKEN_INVALID, 0 }
      89             :                     };
      90          10 :                     rReturn = aSubmitEncodingMap;
      91             :                 }
      92          10 :                 break;
      93             :                 // FormSubmitMethod
      94             :                 case epSubmitMethod:
      95             :                 {
      96             :                     static SvXMLEnumMapEntry aSubmitMethodMap[] =
      97             :                     {
      98             :                         { XML_GET, FormSubmitMethod_GET },
      99             :                         { XML_POST, FormSubmitMethod_POST },
     100             :                         { XML_TOKEN_INVALID, 0 }
     101             :                     };
     102          10 :                     rReturn = aSubmitMethodMap;
     103             :                 }
     104          10 :                 break;
     105             :                 // CommandType
     106             :                 case epCommandType:
     107             :                 {
     108             :                     static SvXMLEnumMapEntry aCommandTypeMap[] =
     109             :                     {
     110             :                         { XML_TABLE, CommandType::TABLE },
     111             :                         { XML_QUERY, CommandType::QUERY },
     112             :                         { XML_COMMAND, CommandType::COMMAND },
     113             :                         { XML_TOKEN_INVALID, 0 }
     114             :                     };
     115          10 :                     rReturn = aCommandTypeMap;
     116             :                 }
     117          10 :                 break;
     118             :                 // NavigationBarMode
     119             :                 case epNavigationType:
     120             :                 {
     121             :                     static SvXMLEnumMapEntry aNavigationTypeMap[] =
     122             :                     {
     123             :                         { XML_NONE, NavigationBarMode_NONE },
     124             :                         { XML_CURRENT, NavigationBarMode_CURRENT },
     125             :                         { XML_PARENT, NavigationBarMode_PARENT },
     126             :                         { XML_TOKEN_INVALID, 0 }
     127             :                     };
     128          10 :                     rReturn = aNavigationTypeMap;
     129             :                 };
     130          10 :                 break;
     131             :                 // TabulatorCycle
     132             :                 case epTabCyle:
     133             :                 {
     134             :                     static SvXMLEnumMapEntry aTabulytorCycleMap[] =
     135             :                     {
     136             :                         { XML_RECORDS, TabulatorCycle_RECORDS },
     137             :                         { XML_CURRENT, TabulatorCycle_CURRENT },
     138             :                         { XML_PAGE, TabulatorCycle_PAGE },
     139             :                         { XML_TOKEN_INVALID, 0 }
     140             :                     };
     141          10 :                     rReturn = aTabulytorCycleMap;
     142             :                 };
     143          10 :                 break;
     144             :                 // FormButtonType
     145             :                 case epButtonType:
     146             :                 {
     147             :                     static SvXMLEnumMapEntry aFormButtonTypeMap[] =
     148             :                     {
     149             :                         { XML_PUSH, FormButtonType_PUSH },
     150             :                         { XML_SUBMIT, FormButtonType_SUBMIT },
     151             :                         { XML_RESET, FormButtonType_RESET },
     152             :                         { XML_URL, FormButtonType_URL },
     153             :                         { XML_TOKEN_INVALID, 0 }
     154             :                     };
     155          10 :                     rReturn = aFormButtonTypeMap;
     156             :                 };
     157          10 :                 break;
     158             :                 // ListSourceType
     159             :                 case epListSourceType:
     160             :                 {
     161             :                     static SvXMLEnumMapEntry aListSourceTypeMap[] =
     162             :                     {
     163             :                         { XML_VALUE_LIST, ListSourceType_VALUELIST },
     164             :                         { XML_TABLE, ListSourceType_TABLE },
     165             :                         { XML_QUERY, ListSourceType_QUERY },
     166             :                         { XML_SQL, ListSourceType_SQL },
     167             :                         { XML_SQL_PASS_THROUGH, ListSourceType_SQLPASSTHROUGH },
     168             :                         { XML_TABLE_FIELDS, ListSourceType_TABLEFIELDS },
     169             :                         { XML_TOKEN_INVALID, 0 }
     170             :                     };
     171          10 :                     rReturn = aListSourceTypeMap;
     172             :                 };
     173          10 :                 break;
     174             :                 // check state of a checkbox
     175             :                 case epCheckState:
     176             :                 {
     177             :                     static SvXMLEnumMapEntry aCheckStateMap[] =
     178             :                     {
     179             :                         { XML_UNCHECKED, STATE_NOCHECK },
     180             :                         { XML_CHECKED, STATE_CHECK },
     181             :                         { XML_UNKNOWN, STATE_DONTKNOW },
     182             :                         { XML_TOKEN_INVALID, 0 }
     183             :                     };
     184          10 :                     rReturn = aCheckStateMap;
     185             :                 };
     186          10 :                 break;
     187             :                 case epTextAlign:
     188             :                 {
     189             :                     static SvXMLEnumMapEntry aTextAlignMap[] =
     190             :                     {
     191             :                         { XML_START,        awt::TextAlign::LEFT },
     192             :                         { XML_CENTER,       awt::TextAlign::CENTER },
     193             :                         { XML_END,          awt::TextAlign::RIGHT },
     194             :                         { XML_JUSTIFY,      (sal_uInt16)-1 },
     195             :                         { XML_JUSTIFIED,    (sal_uInt16)-1 },
     196             :                         { XML_TOKEN_INVALID, 0 }
     197             :                     };
     198           2 :                     rReturn = aTextAlignMap;
     199             :                 };
     200           2 :                 break;
     201             :                 case epBorderWidth:
     202             :                 {
     203             :                     static SvXMLEnumMapEntry aBorderTypeMap[] =
     204             :                     {
     205             :                         { XML_NONE,     0 },
     206             :                         { XML_HIDDEN,   0 },
     207             :                         { XML_SOLID,    2 },
     208             :                         { XML_DOUBLE,   2 },
     209             :                         { XML_DOTTED,   2 },
     210             :                         { XML_DASHED,   2 },
     211             :                         { XML_GROOVE,   1 },
     212             :                         { XML_RIDGE,    1 },
     213             :                         { XML_INSET,    1 },
     214             :                         { XML_OUTSET,   1 },
     215             :                         { XML_TOKEN_INVALID, 0 }
     216             :                     };
     217           1 :                     rReturn = aBorderTypeMap;
     218             :                 };
     219           1 :                 break;
     220             : 
     221             :                 case epFontEmphasis:
     222             :                 {
     223             :                     static SvXMLEnumMapEntry aFontEmphasisMap[] =
     224             :                     {
     225             :                         { XML_NONE,     awt::FontEmphasisMark::NONE },
     226             :                         { XML_DOT,      awt::FontEmphasisMark::DOT },
     227             :                         { XML_CIRCLE,   awt::FontEmphasisMark::CIRCLE },
     228             :                         { XML_DISC,     awt::FontEmphasisMark::DISC },
     229             :                         { XML_ACCENT,   awt::FontEmphasisMark::ACCENT },
     230             :                         { XML_TOKEN_INVALID, 0 }
     231             :                     };
     232           2 :                     rReturn = aFontEmphasisMap;
     233             :                 }
     234           2 :                 break;
     235             : 
     236             :                 case epFontRelief:
     237             :                 {
     238             :                     static SvXMLEnumMapEntry aFontReliefMap[] =
     239             :                     {
     240             :                         { XML_NONE,     FontRelief::NONE },
     241             :                         { XML_ENGRAVED, FontRelief::ENGRAVED },
     242             :                         { XML_EMBOSSED, FontRelief::EMBOSSED },
     243             :                         { XML_TOKEN_INVALID, 0 }
     244             :                     };
     245           2 :                     rReturn = aFontReliefMap;
     246             :                 }
     247           2 :                 break;
     248             : 
     249             :                 case epListLinkageType:
     250             :                 {
     251             :                     static SvXMLEnumMapEntry aListLinkageMap[] =
     252             :                     {
     253             :                         { XML_SELECTION,            0 },
     254             :                         { XML_SELECTION_INDEXES,    1 },
     255             :                         { XML_TOKEN_INVALID, 0 }
     256             :                     };
     257           0 :                     rReturn = aListLinkageMap;
     258             :                 }
     259           0 :                 break;
     260             : 
     261             :                 case epOrientation:
     262             :                 {
     263             :                     static SvXMLEnumMapEntry aOrientationMap[] =
     264             :                     {
     265             :                         { XML_HORIZONTAL,   ScrollBarOrientation::HORIZONTAL },
     266             :                         { XML_VERTICAL,     ScrollBarOrientation::VERTICAL },
     267             :                         { XML_TOKEN_INVALID, 0 }
     268             :                     };
     269          10 :                     rReturn = aOrientationMap;
     270             :                 }
     271          10 :                 break;
     272             : 
     273             :                 case epVisualEffect:
     274             :                 {
     275             :                     static SvXMLEnumMapEntry aVisualEffectMap[] =
     276             :                     {
     277             :                         { XML_NONE, VisualEffect::NONE },
     278             :                         { XML_3D,   VisualEffect::LOOK3D },
     279             :                         { XML_FLAT, VisualEffect::FLAT },
     280             :                         { XML_TOKEN_INVALID, 0 }
     281             :                     };
     282          10 :                     rReturn = aVisualEffectMap;
     283             :                 }
     284          10 :                 break;
     285             : 
     286             :                 case epImagePosition:
     287             :                 {
     288             :                     static SvXMLEnumMapEntry aImagePositionMap[] =
     289             :                     {
     290             :                         { XML_START,  0 },
     291             :                         { XML_END,    1 },
     292             :                         { XML_TOP,    2 },
     293             :                         { XML_BOTTOM, 3 },
     294             :                         { XML_CENTER, (sal_uInt16)-1 },
     295             :                         { XML_TOKEN_INVALID, 0 }
     296             :                     };
     297           0 :                     rReturn = aImagePositionMap;
     298             :                 }
     299           0 :                 break;
     300             : 
     301             :                 case epImageAlign:
     302             :                 {
     303             :                     static SvXMLEnumMapEntry aImageAlignMap[] =
     304             :                     {
     305             :                         { XML_START,  0 },
     306             :                         { XML_CENTER, 1 },
     307             :                         { XML_END, 2 },
     308             :                         { XML_TOKEN_INVALID, 0 }
     309             :                     };
     310           0 :                     rReturn = aImageAlignMap;
     311             :                 }
     312           0 :                 break;
     313             : 
     314             :                 case epImageScaleMode:
     315             :                 {
     316             :                     static const SvXMLEnumMapEntry aScaleModeMap[] =
     317             :                     {
     318             :                         { XML_BACKGROUND_NO_REPEAT, ImageScaleMode::None },
     319             :                         { XML_REPEAT,               ImageScaleMode::None },  // repeating the image is not supported
     320             :                         { XML_STRETCH,              ImageScaleMode::Anisotropic },
     321             :                         { XML_SCALE,                ImageScaleMode::Isotropic },
     322             :                         { XML_TOKEN_INVALID,        ImageScaleMode::None }
     323             :                     };
     324          10 :                     rReturn = aScaleModeMap;
     325             :                 }
     326          10 :                 break;
     327             : 
     328             :                 case KNOWN_ENUM_PROPERTIES:
     329           0 :                     break;
     330             :             }
     331             :         }
     332             : 
     333        1025 :         return rReturn;
     334             :     }
     335             : 
     336             : //.........................................................................
     337             : }   // namespace xmloff
     338             : //.........................................................................
     339             : 
     340             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10