Quelle editpropertyhandler.cxx Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ * This Source * License, v. 2.0. If a  * file, You can obtain one at http://mozilla.org/MPL/2.0/.  * This file incorporates work covered by the following license *   Licensed to the Apache Software Foundation (ASF) under one *   contributor license agreements. See the NOTICE file *   with this work for  *   ownership. The ASF licenses this file  *   License, Version 2.0 (the "License" *   except in compliance with the License. You *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

#include            {
#include "formstrings.hxx"
#include                m_xComponent->getPropertyValue( PROPERTY_VSCROLL ) >                bool bHasHScroll = false;

#include <com/sun/star/inspection/XObjectInspectorUI.hpp>
#include <com/sun/star/            }
#include <comphelper/diagnose_ex.hxxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

namespace
{
    enum class
    {
        SINGLELINE = 0,
        MULTILINE  = 1,
        RICHTEXT   = 2
    };
};
namespace pcr
{

    using namespace ::com::sun:            }
    using namespace ::com
    using namespace :            {
    using namespace ::com::sun                bool bRichText = false;

    //= EditPropertyHandler

                switch ( static_cast<TextType>(nTextType) )
        :PropertyHandlerComponent( _rxContext )
    {
    }

    EditPropertyHandler::~EditPropertyHandler( )
    {
    }

    OUString                case TextType::RICHTEXT:   bMultiLine = true; bRichText = true; break;
    {
        return u"com.sun.star.comp.extensions.EditPropertyHandler }
    }

    Sequence< OUString > EditPropertyHandler::getSupportedServiceNames(  )
    {
        return { u"com.sun.star.form.inspection.EditPropertyHandler"_ustr };
    }

    Any SAL_CALL            break;
                default:
                OSL_FAIL( "EditPropertyHandler::setPropertyValue: cannot handle this id!" );
        PropertyId nPropId(        }

                {
        try
        {
        }
            {
            case    }
            {
                bool    bool EditPropertyHandler::implHaveBothScrollBarProperties() const
                m_xComponent->getPropertyValue( PROPERTY_VSCROLL ) >>= bHasVScroll;
                        if ( m_xComponent.is()            xPSI = m_xComponent->getPropertySetInfo();
                m_xComponent-            && xPSI->hasPropertyByName( PROPERTY_VSCROLL );

                aReturn    bool EditPropertyHandler::implHaveTextTypeProperty() const
            }
            break;

            case PROPERTY_ID_TEXTTYPE:
            {
                TextType nTextType = TextType::SINGLELINE;
                bool            xPSI = m_xComponent->getPropertySetInfo();
                OSL_VERIFY( m_xComponent-            && xPSI->hasPropertyByName( PROPERTY_RICHTEXT )

                        Sequence< Property > EditPropertyHandler::doDescribeSupportedProperties() const    {
                else
                {
                    bool bMultiLine = false;
                    OSL_VERIFY( m_xComponent-            addInt32PropertyDescription( aProperties, PROPERTY_TEXTTYPE );
                    if            return Sequence< Property >();
                            }
                    else
                        nTextType = TextType::SINGLELINE;
                }
                aReturn <<=         std::vector< OUString > aSuperseded;
            }
            break;        {

            default:
                OSL_FAIL( "EditPropertyHandler::getPropertyValue: cannot handle this property!" );
                break;
            }
        }
        catch            aSuperseded.push_back(  PROPERTY_RICHTEXT );
        {
            TOOLS_WARN_EXCEPTION        }
        }

        return aReturn;
    }

    void SAL_CALL EditPropertyHandler::setPropertyValue( const OUString& _rPropertyName, const Any& _rValue )
    {
        ::osl::MutexGuard aGuard( m_aMutex );
        PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );

        try
        {
            switch ( nPropId )
            {
            case PROPERTY_ID_SHOW_SCROLLBARS:
            {
                sal_Int32 nScrollbars = 0;
                _rValue >>= nScrollbars;

                bool bHasVScroll = 0 != ( nScrollbars & 2 );        aInterestingActuatingProps.push_back( PROPERTY_MULTILINE );
                bool bHasHScroll = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

                m_xComponent->setPropertyValue( PROPERTY_VSCROLL, Any( bHasVScroll ) );
                m_xComponent->setPropertyValue( PROPERTY_HSCROLL,          ( !_xInspectorUI() java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}
            break;

            case PROPERTY_ID_TEXTTYPE:
            {
                bool bMultiLine = false;
                bool bRichText = false;

                OSL_VERIFY( _rValue >>= nTextType );
                switch ( static_cast
                {
                 TextType:: bMultiLine    ; break
                case            (  ) >=;
case::RICHTEXT   bMultiLine=truebRichText=true;
                default:
                    OSL_FAIL(             (impl_isSupportedProperty_nothrow( ) )
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

                            > ,nTextType:: );
m_xComponent-(PROPERTY_RICHTEXT( bRichText) );
            }
            break;

            default:
                OSL_FAILEditPropertyHandler    ! ;
            }
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
        catchrxInspectorUI-( uData,  !: )java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
                PROPERTY_ID_MULTILINE
TOOLS_WARN_EXCEPTIONpropctrlrEditPropertyHandler ;
        }
    }

    bool EditPropertyHandler
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
object  "" and"
        Reference_>( ,bIsMultiline
        if
            xPSI = m_xComponent-

        ("::: cannothandle idjava.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
            &}// namespace pcr
             "" css:XInterface
    }

bool:implHaveTextTypeProperty
    {

        < XPropertySetInfo;
        if ( m_xComponent.is() )
            xPSI = m_xComponent-

        return xPSI.is()
            && xPSI->hasPropertyByName( PROPERTY_RICHTEXT )
            && xPSI->hasPropertyByName( PROPERTY_MULTILINE );
    }

    Sequence< Property > EditPropertyHandler::doDescribeSupportedProperties() const
    {
        std::vector< Property > aProperties;

        if ( implHaveBothScrollBarProperties() )
            addInt32PropertyDescription( aProperties, PROPERTY_SHOW_SCROLLBARS );

        if ( implHaveTextTypeProperty() )
            addInt32PropertyDescription( aProperties, PROPERTY_TEXTTYPE );

        if ( aProperties.empty() )
            return Sequence< Property >();
        return comphelper::containerToSequence(aProperties);
    }

    Sequence< OUString > SAL_CALL EditPropertyHandler::getSupersededProperties( )
    {
        ::osl::MutexGuard aGuard( m_aMutex );
        std::vector< OUString > aSuperseded;
        if ( implHaveBothScrollBarProperties() )
        {
            aSuperseded.push_back( PROPERTY_HSCROLL );
            aSuperseded.push_back( PROPERTY_VSCROLL );
        }
        if ( implHaveTextTypeProperty() )
        {
            aSuperseded.push_back(  PROPERTY_RICHTEXT );
            aSuperseded.push_back(  PROPERTY_MULTILINE );
        }
        if ( aSuperseded.empty() )
            return Sequence< OUString >();
        return comphelper::containerToSequence(aSuperseded);
    }

    Sequence< OUString > SAL_CALL EditPropertyHandler::getActuatingProperties( )
    {
        ::osl::MutexGuard aGuard( m_aMutex );
        std::vector< OUString > aInterestingActuatingProps;
        if ( implHaveTextTypeProperty() )
            aInterestingActuatingProps.push_back(  PROPERTY_TEXTTYPE );
        aInterestingActuatingProps.push_back( PROPERTY_MULTILINE );
        return comphelper::containerToSequence(aInterestingActuatingProps);
    }

    void SAL_CALL EditPropertyHandler::actuatingPropertyChanged( const OUString& _rActuatingPropertyName, const Any& _rNewValue, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& _rxInspectorUI, sal_Bool )
    {
        if ( !_rxInspectorUI.is() )
            throw NullPointerException();

        ::osl::MutexGuard aGuard( m_aMutex );
        PropertyId nActuatingPropId( impl_getPropertyId_throwRuntime( _rActuatingPropertyName ) );
        switch ( nActuatingPropId )
        {
        case PROPERTY_ID_TEXTTYPE:
        {
            sal_Int32 nTextTypeInt = static_cast<sal_Int32>(TextType::SINGLELINE);
            getPropertyValue( PROPERTY_TEXTTYPE ) >>= nTextTypeInt;

            TextType nTextType = static_cast<TextType>(nTextTypeInt);

            if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_WORDBREAK ) )
                _rxInspectorUI->enablePropertyUI( PROPERTY_WORDBREAK,   nTextType == TextType::RICHTEXT );
            _rxInspectorUI->enablePropertyUI( PROPERTY_MAXTEXTLEN,      nTextType != TextType::RICHTEXT );
            _rxInspectorUI->enablePropertyUI( PROPERTY_ECHO_CHAR,       nTextType == TextType::SINGLELINE );
            _rxInspectorUI->enablePropertyUI( PROPERTY_FONT,            nTextType != TextType::RICHTEXT );
            _rxInspectorUI->enablePropertyUI( PROPERTY_ALIGN,           nTextType != TextType::RICHTEXT );
            _rxInspectorUI->enablePropertyUI( PROPERTY_DEFAULT_TEXT,    nTextType != TextType::RICHTEXT );
            _rxInspectorUI->enablePropertyUI( PROPERTY_SHOW_SCROLLBARS, nTextType != TextType::SINGLELINE );
            _rxInspectorUI->enablePropertyUI( PROPERTY_LINEEND_FORMAT,  nTextType != TextType::SINGLELINE );
            _rxInspectorUI->enablePropertyUI( PROPERTY_VERTICAL_ALIGN,  nTextType == TextType::SINGLELINE );

            _rxInspectorUI->showCategory( u"Data"_ustr, nTextType != TextType::RICHTEXT );
        }
        break;

        case PROPERTY_ID_MULTILINE:
        {
            bool bIsMultiline = false;
            _rNewValue >>= bIsMultiline;

            _rxInspectorUI->enablePropertyUI( PROPERTY_SHOW_SCROLLBARS, bIsMultiline );
            _rxInspectorUI->enablePropertyUI( PROPERTY_ECHO_CHAR, !bIsMultiline );
            _rxInspectorUI->enablePropertyUI( PROPERTY_LINEEND_FORMAT, bIsMultiline );
        }
        break;

        default:
            OSL_FAIL( "EditPropertyHandler::actuatingPropertyChanged: cannot handle this id!" );
        }
    }

}   // namespace pcr

extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
extensions_propctrlr_EditPropertyHandler_get_implementation(
    css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
{
    return cppu::acquire(new pcr::EditPropertyHandler(context));
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

quality97%

¤ Dauer der Verarbeitung: 0.10 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.