From a86bef45ec2c2ba16de5c552e206a07dc190f497 Mon Sep 17 00:00:00 2001 From: Kohei Yoshida Date: Thu, 26 Jul 2012 10:02:33 -0400 Subject: Fix excessive indentation. Change-Id: Id96c7693a53981d69820aa45e97fb34c64cb787a --- framework/source/inc/loadenv/loadenv.hxx | 1062 +++++++++++++++--------------- 1 file changed, 531 insertions(+), 531 deletions(-) (limited to 'framework') diff --git a/framework/source/inc/loadenv/loadenv.hxx b/framework/source/inc/loadenv/loadenv.hxx index a38926121c8d..edd5e55c6254 100644 --- a/framework/source/inc/loadenv/loadenv.hxx +++ b/framework/source/inc/loadenv/loadenv.hxx @@ -73,538 +73,538 @@ class QuietInteraction; */ class LoadEnv : private ThreadHelpBase { - public: - - /** @short enable/disable special features - of a load request. - - @desrc Such features must outcome without - any special parameters. - To make enableing/disabling of - features very easy (e.g. at the ctor of - this class) these values must be combinable - as flags. That means: its values must be in - range of [2^n]! - */ - enum EFeature - { - /// we should be informed, if no feature is enabled :-) - E_NO_FEATURE = 0, - /// enable using of UI elements during loading (means progress, interaction handler etcpp.) - E_WORK_WITH_UI = 1, - /// enable loading of resources, which are not related to a target frame! (see concept of ContentHandler) - E_ALLOW_CONTENTHANDLER = 2 - }; - - /** @short classify a content. - - @descr The load environment must know, if a content - is related to a target frame or not. Only "visible" - components, which full fill the requirements of the - model-controller-view paradigm can be loaded into a frame. - Such contents are classified as E_CAN_BE_LOADED. - - But e.g. for the dispatch framework exists special ContentHandler - objects, which can load a content in "non visible" mode ... - and do not need a target frame for its operation. Such - ContentHandler e.g. plays sounds. - Such contents are classified as E_CAN_BE_HANDLED. - - And last but not least a content can be "not valid" in general. - */ - enum EContentType - { - /// identifies a content, which seems to be invalid in general - E_UNSUPPORTED_CONTENT, - /// identifies a content, which can be used with a ContentHandler and is not related to a target frame - E_CAN_BE_HANDLED, - /// identifies a content, which can be loaded into a target frame - E_CAN_BE_LOADED, - /// special mode for non real loading, In such case the model is given directly! - E_CAN_BE_SET - }; - - private: - - /** @short reference to an uno service manager, which must be used - to created on needed services on demand. - */ - css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; - - /** @short points to the frame, which uses this LoadEnv object - and must be used to start target search there. - */ - css::uno::Reference< css::frame::XFrame > m_xBaseFrame; - - /** @short points to the frame, into which the new component was loaded. - - @descr Note: This reference will be empty if loading failed - or a non visible content was loaded! - It can be the same frame as m_xBaseFrame it describe, in case - the target "_self", "" or the search flag "SELF" was used. - Otherwhise its the new created or recycled frame, which was - used for loading and contains further the new component. - - Please use method getTarget() or getTargetComponent() - to return the frame/controller or model to any interested - user of the results of this load request. - */ - css::uno::Reference< css::frame::XFrame > m_xTargetFrame; - - /** @short contains the name of the target, in which the specified resource - of this instance must be loaded. - */ - ::rtl::OUString m_sTarget; - - /** @short if m_sTarget is not a special one, this flags regulate searching - of a suitable one. - */ - sal_Int32 m_nSearchFlags; - - /** @short contains all needed informations about the resource, - which should be loaded. - - @descr Inside this struct e.g. the URL, its type and filter name, - the stream or a model directly are saved. - */ - ::comphelper::MediaDescriptor m_lMediaDescriptor; - - /** @short because the mediadescriptor contains the complete URL ... but - some functionality need the structured version, we hold it twice :-(. - */ - css::util::URL m_aURL; - - /** @short enable/disable special features of a load request. */ - EFeature m_eFeature; - - /** @short classify the content, which should be loaded by this instance. */ - EContentType m_eContentType; - - /** @short it indicates, that the member m_xTargetFrame was new created for this - load request and must be closed in case loading (not handling!) - operation failed. The default value is sal_False! - */ - sal_Bool m_bCloseFrameOnError; - - /** @short it indicates, that the old document (which was located inside m_xBaseFrame - in combination with the m_sTarget value "_self") was suspended. - Normaly it will be replaced by the new loaded document. But in case - loading (not handling!) failed, it must be reactivated. - The default value is sal_False! - */ - sal_Bool m_bReactivateControllerOnError; - - /** @short it holds one (!) asynchronous used contenthandler or frameloader - alive, till the asynchronous operation will be finished. - */ - css::uno::Reference< css::uno::XInterface > m_xAsynchronousJob; - - /** @short holds the information about the finished load process. - - @descr The content of m_xTargetFrame cant be used as valid indicator, - (in case the micht existing old document was reactivated) - we must hold the result of the load process explicitly. - */ - sal_Bool m_bLoaded; - - /** @short holds an XActionLock on the internal used task member. - - @seealso m_xTargetFrame - */ - ActionLockGuard m_aTargetLock; - - QuietInteraction* m_pQuietInteraction; - - public: - - /** @short initialize a new instance of this load environment. - - @param xSMGR - reference to an uno service manager, which can be used internaly - to create on needed services on demand. - - @throw Currently there is no reason to throw such exception! - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - LoadEnv(const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR) - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short deinitialize an instance of this class in the right way. - */ - ~LoadEnv(); - - static css::uno::Reference< css::lang::XComponent > loadComponentFromURL(const css::uno::Reference< css::frame::XComponentLoader >& xLoader, - const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR , - const ::rtl::OUString& sURL , - const ::rtl::OUString& sTarget, - sal_Int32 nFlags , - const css::uno::Sequence< css::beans::PropertyValue >& lArgs ) - throw(css::lang::IllegalArgumentException, - css::io::IOException , - css::uno::RuntimeException ); - - /** @short set some changeable parameters for a new load request. - - @descr The parameter for targeting, the content description, and - some environment specifier (UI, dispatch functionality) - can be set here ... BEFORE the real load process is started - by calling startLoading(). Of course a still running load request - will be detected here and a suitable exception will be thrown. - Such constellation can be detected outside by using provided - synchronisation methods or callbacks. - - @param sURL - points to the resource, which should be loaded. - - @param lMediaDescriptor - contains additional informations for the following load request. - - @param xBaseFrame - points to the frame which must be used as start point for target search. - - @param sTarget - regulate searching/creating of frames, which should contain the - new loaded component afterwards. - - @param nSearchFlags - regulate searching of targets, if sTarget is not a special one. - - @param eFeature - flag field, which enable/disable special features of this - new instance for following load call. - - @param eContentType - classify the given content. - This value is set to a default value "UNKNWON_CONTENT", which force - an internal check, if this content is loadable or not. - But may this check was already made by the caller of this method and - passing this information to this LoadEnv instance can supress this - might expensive check. - That can be usefull in case this information is needed outside too, - to decide if its neccessary to create some resources for this load - request ... or to reject the request imidiatly if it seems to be not - loadable in general. - - @throw A LoadEnvException e.g. if another load operation is till in progress - or initialization of a new one fail by other reasons. - The real reason, a suitable message and ID will be given here immidiatly. - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - void initializeLoading(const ::rtl::OUString& sURL , - const css::uno::Sequence< css::beans::PropertyValue >& lMediaDescriptor, - const css::uno::Reference< css::frame::XFrame >& xBaseFrame , - const ::rtl::OUString& sTarget , - sal_Int32 nSearchFlags , - EFeature eFeature = E_NO_FEATURE , - EContentType eContentType = E_UNSUPPORTED_CONTENT); - - /** @short start loading of the resource represented by this loadenv instance. - - @descr There is no direct return value possible here. Because it depends - from the usage of this instance! E.g. for loading a "visible component" - a frame with a controller/model inside can be possible. For loading - of a "non visible component" only an information about a successfully start - can be provided. - Further it cant be guranteed, that the internal process runs synchronous. - Thats why we preferr using of specialized methods afterwards e.g. to: - - wait till the internal job will be finished - and get the results - - or to let it run without any further control from outside. - - @throw A LoadEnvException if start of the load process failed (because - another is still in progress!). - The reason, a suitable message and ID will be given here immidiatly. - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - void startLoading(); - - //_______________________________________ - - /** @short wait for an alreay running load request (started by calling - startLoading() before). - - @descr The timeout parameter can be used to wait some times only - or forever. The return value indicates if the load request - was finished during the specified timeout period. - But it indicates not, if the load request was successfully or not! - - @param nTimeout - specify a timeout in [ms]. - A value 0 let it wait forever! - - @return sal_True if the started load process could be finished in time; - sal_False if the specified time was over. - - @throw ... currently not used :-) - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - sal_Bool waitWhileLoading(sal_uInt32 nTimeout = 0); - - //_______________________________________ - /** TODO document me ... */ - css::uno::Reference< css::lang::XComponent > getTargetComponent() const; - - public: - - /** @short checks if the specified content can be handled by a - ContentHandler only and is not related to a target frame, - or if it can be loaded by a FrameLoader into a target frame - as "visible" component. - - @descr using: - switch(classifyContent(...)) - { - case E_CAN_BE_HANDLED : - handleIt(...); - break; - - case E_CAN_BE_LOADED : - xFrame = locateTargetFrame(); - loadIt(xFrame); - break; - - case E_NOT_A_CONTENT : - default : throw ...; - } - - @param sURL - describe the content. - - @param lMediaDescriptor - describe the content more detailed! - - @return A suitable enum value, which classify the specified content. - */ - static EContentType classifyContent(const ::rtl::OUString& sURL , - const css::uno::Sequence< css::beans::PropertyValue >& lMediaDescriptor); - - /** TODO document me ... */ - static void initializeUIDefaults( - const css::uno::Reference< css::lang::XMultiServiceFactory >& i_rSMGR, - ::comphelper::MediaDescriptor& io_lMediaDescriptor, - const bool _bUIMode, - QuietInteraction** o_ppQuiteInteraction - ); - - /** TODO document me ... */ - void impl_setResult(sal_Bool bResult); - - /** TODO document me ... */ - css::uno::Reference< css::uno::XInterface > impl_searchLoader(); - - //_______________________________________ - - /** @short it means; show the frame, bring it to front, - might set the right icon etcpp. in case loading was - successfully or reactivate a might existing old document or - close the frame if it was created before in case loading failed. - - @throw A LoadEnvException only in cases, where an internal error indicates, - that the complete load environment seems to be not useable in general. - In such cases a RuntimeException would be to hard for the outside code :-) - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - void impl_reactForLoadingState() - throw(LoadEnvException, css::uno::RuntimeException); - - private: +public: + + /** @short enable/disable special features + of a load request. + + @desrc Such features must outcome without + any special parameters. + To make enableing/disabling of + features very easy (e.g. at the ctor of + this class) these values must be combinable + as flags. That means: its values must be in + range of [2^n]! + */ + enum EFeature + { + /// we should be informed, if no feature is enabled :-) + E_NO_FEATURE = 0, + /// enable using of UI elements during loading (means progress, interaction handler etcpp.) + E_WORK_WITH_UI = 1, + /// enable loading of resources, which are not related to a target frame! (see concept of ContentHandler) + E_ALLOW_CONTENTHANDLER = 2 + }; + + /** @short classify a content. + + @descr The load environment must know, if a content + is related to a target frame or not. Only "visible" + components, which full fill the requirements of the + model-controller-view paradigm can be loaded into a frame. + Such contents are classified as E_CAN_BE_LOADED. + + But e.g. for the dispatch framework exists special ContentHandler + objects, which can load a content in "non visible" mode ... + and do not need a target frame for its operation. Such + ContentHandler e.g. plays sounds. + Such contents are classified as E_CAN_BE_HANDLED. + + And last but not least a content can be "not valid" in general. + */ + enum EContentType + { + /// identifies a content, which seems to be invalid in general + E_UNSUPPORTED_CONTENT, + /// identifies a content, which can be used with a ContentHandler and is not related to a target frame + E_CAN_BE_HANDLED, + /// identifies a content, which can be loaded into a target frame + E_CAN_BE_LOADED, + /// special mode for non real loading, In such case the model is given directly! + E_CAN_BE_SET + }; + +private: + + /** @short reference to an uno service manager, which must be used + to created on needed services on demand. + */ + css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; + + /** @short points to the frame, which uses this LoadEnv object + and must be used to start target search there. + */ + css::uno::Reference< css::frame::XFrame > m_xBaseFrame; + + /** @short points to the frame, into which the new component was loaded. + + @descr Note: This reference will be empty if loading failed + or a non visible content was loaded! + It can be the same frame as m_xBaseFrame it describe, in case + the target "_self", "" or the search flag "SELF" was used. + Otherwhise its the new created or recycled frame, which was + used for loading and contains further the new component. + + Please use method getTarget() or getTargetComponent() + to return the frame/controller or model to any interested + user of the results of this load request. + */ + css::uno::Reference< css::frame::XFrame > m_xTargetFrame; + + /** @short contains the name of the target, in which the specified resource + of this instance must be loaded. + */ + ::rtl::OUString m_sTarget; + + /** @short if m_sTarget is not a special one, this flags regulate searching + of a suitable one. + */ + sal_Int32 m_nSearchFlags; + + /** @short contains all needed informations about the resource, + which should be loaded. + + @descr Inside this struct e.g. the URL, its type and filter name, + the stream or a model directly are saved. + */ + ::comphelper::MediaDescriptor m_lMediaDescriptor; + + /** @short because the mediadescriptor contains the complete URL ... but + some functionality need the structured version, we hold it twice :-(. + */ + css::util::URL m_aURL; + + /** @short enable/disable special features of a load request. */ + EFeature m_eFeature; + + /** @short classify the content, which should be loaded by this instance. */ + EContentType m_eContentType; + + /** @short it indicates, that the member m_xTargetFrame was new created for this + load request and must be closed in case loading (not handling!) + operation failed. The default value is sal_False! + */ + sal_Bool m_bCloseFrameOnError; + + /** @short it indicates, that the old document (which was located inside m_xBaseFrame + in combination with the m_sTarget value "_self") was suspended. + Normaly it will be replaced by the new loaded document. But in case + loading (not handling!) failed, it must be reactivated. + The default value is sal_False! + */ + sal_Bool m_bReactivateControllerOnError; + + /** @short it holds one (!) asynchronous used contenthandler or frameloader + alive, till the asynchronous operation will be finished. + */ + css::uno::Reference< css::uno::XInterface > m_xAsynchronousJob; + + /** @short holds the information about the finished load process. + + @descr The content of m_xTargetFrame cant be used as valid indicator, + (in case the micht existing old document was reactivated) + we must hold the result of the load process explicitly. + */ + sal_Bool m_bLoaded; + + /** @short holds an XActionLock on the internal used task member. + + @seealso m_xTargetFrame + */ + ActionLockGuard m_aTargetLock; + + QuietInteraction* m_pQuietInteraction; + +public: + + /** @short initialize a new instance of this load environment. + + @param xSMGR + reference to an uno service manager, which can be used internaly + to create on needed services on demand. + + @throw Currently there is no reason to throw such exception! + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + LoadEnv(const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR) + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short deinitialize an instance of this class in the right way. + */ + ~LoadEnv(); + + static css::uno::Reference< css::lang::XComponent > loadComponentFromURL(const css::uno::Reference< css::frame::XComponentLoader >& xLoader, + const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR , + const ::rtl::OUString& sURL , + const ::rtl::OUString& sTarget, + sal_Int32 nFlags , + const css::uno::Sequence< css::beans::PropertyValue >& lArgs ) + throw(css::lang::IllegalArgumentException, + css::io::IOException , + css::uno::RuntimeException ); + + /** @short set some changeable parameters for a new load request. + + @descr The parameter for targeting, the content description, and + some environment specifier (UI, dispatch functionality) + can be set here ... BEFORE the real load process is started + by calling startLoading(). Of course a still running load request + will be detected here and a suitable exception will be thrown. + Such constellation can be detected outside by using provided + synchronisation methods or callbacks. + + @param sURL + points to the resource, which should be loaded. + + @param lMediaDescriptor + contains additional informations for the following load request. + + @param xBaseFrame + points to the frame which must be used as start point for target search. + + @param sTarget + regulate searching/creating of frames, which should contain the + new loaded component afterwards. + + @param nSearchFlags + regulate searching of targets, if sTarget is not a special one. + + @param eFeature + flag field, which enable/disable special features of this + new instance for following load call. + + @param eContentType + classify the given content. + This value is set to a default value "UNKNWON_CONTENT", which force + an internal check, if this content is loadable or not. + But may this check was already made by the caller of this method and + passing this information to this LoadEnv instance can supress this + might expensive check. + That can be usefull in case this information is needed outside too, + to decide if its neccessary to create some resources for this load + request ... or to reject the request imidiatly if it seems to be not + loadable in general. + + @throw A LoadEnvException e.g. if another load operation is till in progress + or initialization of a new one fail by other reasons. + The real reason, a suitable message and ID will be given here immidiatly. + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + void initializeLoading(const ::rtl::OUString& sURL , + const css::uno::Sequence< css::beans::PropertyValue >& lMediaDescriptor, + const css::uno::Reference< css::frame::XFrame >& xBaseFrame , + const ::rtl::OUString& sTarget , + sal_Int32 nSearchFlags , + EFeature eFeature = E_NO_FEATURE , + EContentType eContentType = E_UNSUPPORTED_CONTENT); + + /** @short start loading of the resource represented by this loadenv instance. + + @descr There is no direct return value possible here. Because it depends + from the usage of this instance! E.g. for loading a "visible component" + a frame with a controller/model inside can be possible. For loading + of a "non visible component" only an information about a successfully start + can be provided. + Further it cant be guranteed, that the internal process runs synchronous. + Thats why we preferr using of specialized methods afterwards e.g. to: + - wait till the internal job will be finished + and get the results + - or to let it run without any further control from outside. + + @throw A LoadEnvException if start of the load process failed (because + another is still in progress!). + The reason, a suitable message and ID will be given here immidiatly. + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + void startLoading(); + + //_______________________________________ + + /** @short wait for an alreay running load request (started by calling + startLoading() before). + + @descr The timeout parameter can be used to wait some times only + or forever. The return value indicates if the load request + was finished during the specified timeout period. + But it indicates not, if the load request was successfully or not! + + @param nTimeout + specify a timeout in [ms]. + A value 0 let it wait forever! + + @return sal_True if the started load process could be finished in time; + sal_False if the specified time was over. + + @throw ... currently not used :-) + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + sal_Bool waitWhileLoading(sal_uInt32 nTimeout = 0); + + //_______________________________________ + /** TODO document me ... */ + css::uno::Reference< css::lang::XComponent > getTargetComponent() const; + +public: + + /** @short checks if the specified content can be handled by a + ContentHandler only and is not related to a target frame, + or if it can be loaded by a FrameLoader into a target frame + as "visible" component. + + @descr using: + switch(classifyContent(...)) + { + case E_CAN_BE_HANDLED : + handleIt(...); + break; + + case E_CAN_BE_LOADED : + xFrame = locateTargetFrame(); + loadIt(xFrame); + break; + + case E_NOT_A_CONTENT : + default : throw ...; + } + + @param sURL + describe the content. + + @param lMediaDescriptor + describe the content more detailed! + + @return A suitable enum value, which classify the specified content. + */ + static EContentType classifyContent(const ::rtl::OUString& sURL , + const css::uno::Sequence< css::beans::PropertyValue >& lMediaDescriptor); + + /** TODO document me ... */ + static void initializeUIDefaults( + const css::uno::Reference< css::lang::XMultiServiceFactory >& i_rSMGR, + ::comphelper::MediaDescriptor& io_lMediaDescriptor, + const bool _bUIMode, + QuietInteraction** o_ppQuiteInteraction + ); + + /** TODO document me ... */ + void impl_setResult(sal_Bool bResult); + + /** TODO document me ... */ + css::uno::Reference< css::uno::XInterface > impl_searchLoader(); + + //_______________________________________ + + /** @short it means; show the frame, bring it to front, + might set the right icon etcpp. in case loading was + successfully or reactivate a might existing old document or + close the frame if it was created before in case loading failed. + + @throw A LoadEnvException only in cases, where an internal error indicates, + that the complete load environment seems to be not useable in general. + In such cases a RuntimeException would be to hard for the outside code :-) + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + void impl_reactForLoadingState() + throw(LoadEnvException, css::uno::RuntimeException); + +private: - /** @short tries to detect the type and the filter of the specified content. - - @descr This method update the available media descriptor of this instance, - so it contains the right type, a corresponding filter, may a - valid frame loader etc. In case detection failed, this descriptor - is corrected first, before a suitable exception will be thrown. - (Excepting a RuntimeException occure!) - - @attention Not all types we know, are supported by filters. So it does not - indicates an error, if no suitable filter(loader etcpp will be found - for a type. But a type must be detected for the specified content. - Otherwhise its an error and loading cant be finished successfully. - - @throw A LoadEnvException if detection failed. - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - void impl_detectTypeAndFilter() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short tries to ask user for it's filter decision in case - normal detection failed. - - @descr We use a may existing interaction handler to do so. - - @return [string] - the type selected by the user. - - @attention Internaly we update the member m_lMediaDescriptor! - */ - ::rtl::OUString impl_askUserForTypeAndFilterIfAllowed() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short tries to use ContentHandler objects for loading. - - @descr It searches for a suitable content handler object, registered - for the detected content type (must be done before by calling - impl_detectTypeAndFilter()). Because such handler does not depend - from a real target frame, location of such frame will be - supressed here. - In case handle failed all new created resources will be - removed before a suitable exception is thrown. - (Excepting a RuntimeException occure!) - - @return TODO - - @throw A LoadEnvException if handling failed. - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - sal_Bool impl_handleContent() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short tries to use FrameLoader objects for loading. - - @descr First the target frame will be located. If it could be found - or new created a filter/frame loader will be instanciated and - used to load the content into this frame. - In case loading failed all new created resources will be - removed before a suitable exception is thrown. - (Excepting a RuntimeException occure!) - - @return TODO - - @throw A LoadEnvException if loading failed. - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - sal_Bool impl_loadContent() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short checks if the specified content is already loaded. - - @descr It depends from the set target information, if such - search is allowed or not! So this method checks first, - if the target is the special one "_default". - If not it returns with an empty result immidatly! - In case search is allowed, an existing document with the - same URL is searched. If it could be found, the corresponding - view will get the focus and this method return the corresponding frame. - Optional jumpmarks will be accepted here too. So the - view of the document will be updated to show the position - inside the document, which is related to the jumpmark. - - @return A valid reference to the target frame, which contains the already loaded content - and could be activated successfully. An empty reference oterwhise. - - @throw A LoadEnvException only in cases, where an internal error indicates, - that the complete load environment seems to be not useable in general. - In such cases a RuntimeException would be to hard for the outside code :-) - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - css::uno::Reference< css::frame::XFrame > impl_searchAlreadyLoaded() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short search for any target frame, which seems to be useable - for this load request. - - @descr Because this special feature is bound to the target specifier "_default" - its checked inside first. If its not set => this method return an empty - reference. Otherwhise any currently existing frame will be analyzed, if - it can be used here. The following rules exists: - - - - If a suitable target is located it will be locked. Thats why the last rule - exists! If this method returns a valid frame reference, it was locked to be useable - for this load request only. (Dont forget to reset this state later!) - Concurrent LoadEnv instances can synchronize her work be using such locks :-) HOPEFULLY - - @throw A LoadEnvException only in cases, where an internal error indicates, - that the complete load environment seems to be not useable in general. - In such cases a RuntimeException would be to hard for the outside code :-) - - @throw A RuntimeException in case any internal process indicates, that - the whole runtime cant be used any longer. - */ - css::uno::Reference< css::frame::XFrame > impl_searchRecycleTarget() - throw(LoadEnvException, css::uno::RuntimeException); - - /** @short because showing of a frame is needed more then once ... - it's implemented as an seperate method .-) - - @descr Note: Showing of a frame is bound to a special feature ... - a) If we recycle any existing frame, we must bring it to front. - Showing of such frame isnt needed realy .. because we recycle - visible frames only! - b) If the document was already shown (e.g. by our progress implementation) - we do nothing here. The reason behind: The document was already shown .. - and it was already make a top window ... - If the user activated another frame inbetween (because loading needed some time) - it's not allowed to disturb the user again. Then the frame must resists in the background. - c) If the frame was not shown before ... but loading of a visible document into this frame - was finished ... we need both actions: setVisible() and toFront(). - - @param xWindow - points to the container window of a frame. - - @param bForceToFront - if it's set to sal_False ... showing of the window is done more intelligent. - setVisible() is called only if the window was not shown before. - This mode is needed by b) and c) - If it's set to sal_True ... both actions has to be done: setVisible(), toFront()! - This mode is needed by a) - */ - void impl_makeFrameWindowVisible(const css::uno::Reference< css::awt::XWindow >& xWindow , - sal_Bool bForceToFront); - - /** @short checks whether a frame is already used for another load request or not. - - @descr Such frames cant be used for our "recycle feature"! - - @param xFrame - the frame, which should be checked. - - @return [sal_Bool] - sal_True if this frame is already used for loading, - sal_False otherwise. - */ - sal_Bool impl_isFrameAlreadyUsedForLoading(const css::uno::Reference< css::frame::XFrame >& xFrame) const; - - /** @short try to determine the used application module - of this load request and applay right position and size - for this document window ... hopefully before we show it .-) - */ - void impl_applyPersistentWindowState(const css::uno::Reference< css::awt::XWindow >& xWindow); - - /** @short determine if it's allowed to open new document frames. - */ - sal_Bool impl_furtherDocsAllowed(); - - /** @short jumps to the requested bookmark inside a given document. - */ - void impl_jumpToMark(const css::uno::Reference< css::frame::XFrame >& xFrame, - const css::util::URL& aURL ); + /** @short tries to detect the type and the filter of the specified content. + + @descr This method update the available media descriptor of this instance, + so it contains the right type, a corresponding filter, may a + valid frame loader etc. In case detection failed, this descriptor + is corrected first, before a suitable exception will be thrown. + (Excepting a RuntimeException occure!) + + @attention Not all types we know, are supported by filters. So it does not + indicates an error, if no suitable filter(loader etcpp will be found + for a type. But a type must be detected for the specified content. + Otherwhise its an error and loading cant be finished successfully. + + @throw A LoadEnvException if detection failed. + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + void impl_detectTypeAndFilter() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short tries to ask user for it's filter decision in case + normal detection failed. + + @descr We use a may existing interaction handler to do so. + + @return [string] + the type selected by the user. + + @attention Internaly we update the member m_lMediaDescriptor! + */ + ::rtl::OUString impl_askUserForTypeAndFilterIfAllowed() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short tries to use ContentHandler objects for loading. + + @descr It searches for a suitable content handler object, registered + for the detected content type (must be done before by calling + impl_detectTypeAndFilter()). Because such handler does not depend + from a real target frame, location of such frame will be + supressed here. + In case handle failed all new created resources will be + removed before a suitable exception is thrown. + (Excepting a RuntimeException occure!) + + @return TODO + + @throw A LoadEnvException if handling failed. + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + sal_Bool impl_handleContent() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short tries to use FrameLoader objects for loading. + + @descr First the target frame will be located. If it could be found + or new created a filter/frame loader will be instanciated and + used to load the content into this frame. + In case loading failed all new created resources will be + removed before a suitable exception is thrown. + (Excepting a RuntimeException occure!) + + @return TODO + + @throw A LoadEnvException if loading failed. + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + sal_Bool impl_loadContent() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short checks if the specified content is already loaded. + + @descr It depends from the set target information, if such + search is allowed or not! So this method checks first, + if the target is the special one "_default". + If not it returns with an empty result immidatly! + In case search is allowed, an existing document with the + same URL is searched. If it could be found, the corresponding + view will get the focus and this method return the corresponding frame. + Optional jumpmarks will be accepted here too. So the + view of the document will be updated to show the position + inside the document, which is related to the jumpmark. + + @return A valid reference to the target frame, which contains the already loaded content + and could be activated successfully. An empty reference oterwhise. + + @throw A LoadEnvException only in cases, where an internal error indicates, + that the complete load environment seems to be not useable in general. + In such cases a RuntimeException would be to hard for the outside code :-) + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + css::uno::Reference< css::frame::XFrame > impl_searchAlreadyLoaded() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short search for any target frame, which seems to be useable + for this load request. + + @descr Because this special feature is bound to the target specifier "_default" + its checked inside first. If its not set => this method return an empty + reference. Otherwhise any currently existing frame will be analyzed, if + it can be used here. The following rules exists: + + + + If a suitable target is located it will be locked. Thats why the last rule + exists! If this method returns a valid frame reference, it was locked to be useable + for this load request only. (Dont forget to reset this state later!) + Concurrent LoadEnv instances can synchronize her work be using such locks :-) HOPEFULLY + + @throw A LoadEnvException only in cases, where an internal error indicates, + that the complete load environment seems to be not useable in general. + In such cases a RuntimeException would be to hard for the outside code :-) + + @throw A RuntimeException in case any internal process indicates, that + the whole runtime cant be used any longer. + */ + css::uno::Reference< css::frame::XFrame > impl_searchRecycleTarget() + throw(LoadEnvException, css::uno::RuntimeException); + + /** @short because showing of a frame is needed more then once ... + it's implemented as an seperate method .-) + + @descr Note: Showing of a frame is bound to a special feature ... + a) If we recycle any existing frame, we must bring it to front. + Showing of such frame isnt needed realy .. because we recycle + visible frames only! + b) If the document was already shown (e.g. by our progress implementation) + we do nothing here. The reason behind: The document was already shown .. + and it was already make a top window ... + If the user activated another frame inbetween (because loading needed some time) + it's not allowed to disturb the user again. Then the frame must resists in the background. + c) If the frame was not shown before ... but loading of a visible document into this frame + was finished ... we need both actions: setVisible() and toFront(). + + @param xWindow + points to the container window of a frame. + + @param bForceToFront + if it's set to sal_False ... showing of the window is done more intelligent. + setVisible() is called only if the window was not shown before. + This mode is needed by b) and c) + If it's set to sal_True ... both actions has to be done: setVisible(), toFront()! + This mode is needed by a) + */ + void impl_makeFrameWindowVisible(const css::uno::Reference< css::awt::XWindow >& xWindow , + sal_Bool bForceToFront); + + /** @short checks whether a frame is already used for another load request or not. + + @descr Such frames cant be used for our "recycle feature"! + + @param xFrame + the frame, which should be checked. + + @return [sal_Bool] + sal_True if this frame is already used for loading, + sal_False otherwise. + */ + sal_Bool impl_isFrameAlreadyUsedForLoading(const css::uno::Reference< css::frame::XFrame >& xFrame) const; + + /** @short try to determine the used application module + of this load request and applay right position and size + for this document window ... hopefully before we show it .-) + */ + void impl_applyPersistentWindowState(const css::uno::Reference< css::awt::XWindow >& xWindow); + + /** @short determine if it's allowed to open new document frames. + */ + sal_Bool impl_furtherDocsAllowed(); + + /** @short jumps to the requested bookmark inside a given document. + */ + void impl_jumpToMark(const css::uno::Reference< css::frame::XFrame >& xFrame, + const css::util::URL& aURL ); }; } // namespace framework -- cgit