/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ #ifndef __FRAMEWORK_HELPER_STATUSINDICATORFACTORY_HXX_ #define __FRAMEWORK_HELPER_STATUSINDICATORFACTORY_HXX_ // Attention: stl headers must(!) be included at first. Otherwhise it can make trouble // with solaris headers ... #include //_______________________________________________ // include files of own module #include #include #include #include #include #include #include #include //_______________________________________________ // include uno interfaces #include #include #include #include #include #include #include #include #include #include #include #include #ifndef _COM_SUN_STAR_URTIL_XUPDATABLE_HPP_ #include #endif //_______________________________________________ // include others #include #include #include //_______________________________________________ // namespace namespace framework{ //_______________________________________________ // definitions //=============================================== /** @descr This struct hold some informations about all currently running progress proccesses. Because the can be used on a stack, we must cache her states but must paint only the top most one. */ struct IndicatorInfo { //------------------------------------------- // member public: /** @short points to the indicator child, where we hold its states alive here. */ css::uno::Reference< css::task::XStatusIndicator > m_xIndicator; /** @short the last set text for this indicator */ ::rtl::OUString m_sText; /** @short the max range for this indicator. */ sal_Int32 m_nRange; /** @short the last set value for this indicator */ sal_Int32 m_nValue; //------------------------------------------- // interface public: //--------------------------------------- /** @short initialize new instance of this class @param xIndicator the new child indiactor of our factory. @param sText its initial text. @param nRange the max range for this indicator. */ IndicatorInfo(const css::uno::Reference< css::task::XStatusIndicator >& xIndicator, const ::rtl::OUString& sText , sal_Int32 nRange ) { m_xIndicator = xIndicator; m_sText = sText ; m_nRange = nRange ; m_nValue = 0 ; } //--------------------------------------- /** @short Don't forget to free used references! */ ~IndicatorInfo() { m_xIndicator.clear(); } //--------------------------------------------------------------------------------------------------------- /** @short Used to locate an info struct inside a stl structure ... @descr The indicator object itself is used as key. Its values are not interesting then. Because mor then one child indicator can use the same values ... */ sal_Bool operator==(const css::uno::Reference< css::task::XStatusIndicator >& xIndicator) { return (m_xIndicator == xIndicator); } }; /* //--------------------------------------------------------------------------------------------------------- // norm nValue to fit range of 0..100% sal_Int32 calcPercentage() { return ::std::min( (( m_nValue * 100 )/ ::std::max( m_nRange, (sal_Int32)1 ) ), (sal_Int32)100 ); } */ //=============================================== /** @descr Define a lits of child indicator objects and her data. */ typedef ::std::vector< IndicatorInfo > IndicatorStack; //=============================================== /** @short implement a factory service to create new status indicator objects @descr Internaly it uses: - a vcl based - or an uno based and by the frame layouted progress implementation. This factory create different indicators and control his access to a shared output device! Only the last activated component can write his state to this device. All other requests will be cached only. @devstatus ready to use @threadsafe yes */ class StatusIndicatorFactory : public css::lang::XTypeProvider , public css::lang::XServiceInfo , public css::lang::XInitialization , public css::task::XStatusIndicatorFactory , public css::util::XUpdatable , private ThreadHelpBase , public ::cppu::OWeakObject // => XInterface { //------------------------------------------- // member private: /** stack with all current indicator childs. */ IndicatorStack m_aStack; /** uno service manager to create own needed uno resources. */ css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; /** most active indicator child, which could work with our shared indicator window only. */ css::uno::Reference< css::task::XStatusIndicator > m_xActiveChild; /** used to show the progress on the frame (layouted!) or as a plugged vcl window. */ css::uno::Reference< css::task::XStatusIndicator > m_xProgress; /** points to the frame, where we show the progress (in case m_xProgress points to a frame progress. */ css::uno::WeakReference< css::frame::XFrame > m_xFrame; /** points to an outside window, where we show the progress (in case we are plugged into such window). */ css::uno::WeakReference< css::awt::XWindow > m_xPluggWindow; /** Notify us if a fix time is over. We use it to implement an intelligent "Reschedule" ... */ WakeUpThread* m_pWakeUp; /** Our WakeUpThread calls us in our interface method "XUpdatable::update(). There we set this member m_bAllowReschedule to sal_True. Next time if our impl_reschedule() method is called, we know, that an Application::Reschedule() should be made. Because the last made Reschedule can be was taken long time ago ... may be.*/ sal_Bool m_bAllowReschedule; /** enable/disable automatic showing of our parent window. */ sal_Bool m_bAllowParentShow; /** enable/disable rescheduling. Default=enabled*/ sal_Bool m_bDisableReschedule; /** prevent recursive calling of Application::Reschedule(). */ static sal_Int32 m_nInReschedule; /** time where there last start call was made. */ sal_Int32 m_nStartTime; //------------------------------------------- // interface public: //--------------------------------------- // ctor StatusIndicatorFactory(const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR); //--------------------------------------- // XInterface, XTypeProvider, XServiceInfo FWK_DECLARE_XINTERFACE FWK_DECLARE_XTYPEPROVIDER DECLARE_XSERVICEINFO //--------------------------------------- // XInitialization virtual void SAL_CALL initialize(const css::uno::Sequence< css::uno::Any >& lArguments) throw(css::uno::Exception , css::uno::RuntimeException); //--------------------------------------- // XStatusIndicatorFactory virtual css::uno::Reference< css::task::XStatusIndicator > SAL_CALL createStatusIndicator() throw(css::uno::RuntimeException); //--------------------------------------- // XUpdatable virtual void SAL_CALL update() throw(css::uno::RuntimeException); //--------------------------------------- // similar (XStatusIndicator) virtual void start(const css::uno::Reference< css::task::XStatusIndicator >& xChild, const ::rtl::OUString& sText , sal_Int32 nRange); virtual void SAL_CALL reset(const css::uno::Reference< css::task::XStatusIndicator >& xChild); virtual void SAL_CALL end(const css::uno::Reference< css::task::XStatusIndicator >& xChild); virtual void SAL_CALL setText(const css::uno::Reference< css::task::XStatusIndicator >& xChild, const ::rtl::OUString& sText ); virtual void SAL_CALL setValue(const css::uno::Reference< css::task::XStatusIndicator >& xChild, sal_Int32 nValue); //------------------------------------------- // specials protected: virtual ~StatusIndicatorFactory(); //------------------------------------------- // helper private: /** @short show the parent window of this progress ... if it's allowed to do so. @descr By default we show the parent window automaticly if this progress is used. If that isn't a valid operation, the user of this progress can suppress this feature by initializaing us with a special parameter. @seealso initialize() */ void implts_makeParentVisibleIfAllowed(); /** @short creates a new internal used progress. @descr This factory does not paint the progress itself. It uses helper for that. They can be vcl based or layouted by the frame and provided as an uno interface. */ void impl_createProgress(); /** @short shows the internal used progress. @descr This factory does not paint the progress itself. It uses helper for that. They can be vcl based or layouted by the frame and provided as an uno interface. */ void impl_showProgress(); /** @short hides the internal used progress. @descr This factory does not paint the progress itself. It uses helper for that. They can be vcl based or layouted by the frame and provided as an uno interface. */ void impl_hideProgress(); /** @short try to "share the current thread in an intelligent manner" :-) @param Overwrites our algorithm for Reschedule and force it to be shure that our progress was painted right. */ void impl_reschedule(sal_Bool bForceUpdate); void impl_startWakeUpThread(); void impl_stopWakeUpThread(); }; // class StatusIndicatorFactory } // namespace framework #endif // #ifndef __FRAMEWORK_HELPER_STATUSINDICATORFACTORY_HXX_