strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/linguistic/source/gciterator.cxx
Oliver Bolte e0b0e70031 INTEGRATION: CWS gcframework_DEV300 (1.1.2); FILE ADDED 
2008/01/08 09:36:28 tl 1.1.2.5: #i83776# grammar checking framework
2007/12/05 13:19:52 tl 1.1.2.4: #i83776# grammar checking framework
2007/12/05 12:04:17 tl 1.1.2.3: #i83776# grammar checking framework
2007/12/05 12:01:46 tl 1.1.2.2: #i83776# grammar checking framework
2007/12/05 11:49:33 tl 1.1.2.1: #i83776# grammar checking framework
2008-02-26 08:49:22 +00:00

628 lines
23 KiB
C++
Raw Blame History

/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: gciterator.cxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: obo $ $Date: 2008-02-26 09:49:22 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#include "precompiled_linguistic.hxx"
#include <sal/config.h>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <cppuhelper/implbase4.hxx>
#include <com/sun/star/linguistic2/XGrammarCheckingIterator.hpp>
#include <deque>
#include <com/sun/star/text/TextMarkupType.hpp>
#include <com/sun/star/text/XFlatParagraph.hpp>
#include <com/sun/star/text/XFlatParagraphIterator.hpp>
#include <map>
#include <com/sun/star/i18n/XBreakIterator.hpp>
#include <vcl/unohelp.hxx>
#include <osl/mutex.hxx>
#include <vcl/svapp.hxx>
#include <osl/conditn.hxx>
#include <cppuhelper/implbase4.hxx>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/linguistic2/XGrammarCheckingResultListener.hpp>
#include <com/sun/star/linguistic2/XGrammarChecker.hpp>
#include <com/sun/star/linguistic2/XGrammarCheckingResultBroadcaster.hpp>
#include "misc.hxx"
#include "defs.hxx"
#include <cppuhelper/factory.hxx>
#include <com/sun/star/registry/XRegistryKey.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/linguistic2/SingleGrammarError.hpp>
#include "gciterator.hxx"
#include "grammarchecker.hxx"
#include <unotools/processfactory.hxx>
#include <com/sun/star/container/XContentEnumerationAccess.hpp>
#include <com/sun/star/container/XEnumeration.hpp>
#include <cppuhelper/interfacecontainer.h>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <cppuhelper/factory.hxx>
#include "lngopt.hxx"
#include <com/sun/star/linguistic2/XSupportedLocales.hpp>
#include <vcl/unohelp.hxx>
#include <com/sun/star/linguistic2/SingleGrammarError.hpp>
#include <com/sun/star/linguistic2/GrammarCheckingResult.hpp>
#include <cppuhelper/extract.hxx>
#include <i18npool/mslangid.hxx>
#include <osl/thread.hxx>
#include <com/sun/star/text/XTextMarkup.hpp>
using namespace ::utl;
using namespace ::rtl;
using namespace ::com::sun::star;
using namespace linguistic;
extern "C" void workerfunc (void * gci)
{
((GrammarCheckingIterator*)gci)->dequeueAndCheck();
}
////////////////////////////////////////////////////////////
GrammarCheckingIterator::GrammarCheckingIterator( /* uno::Reference< uno::XComponentContext > const & context */ ) :
/*m_xContext(context)*/
m_bEnd( sal_False ),
m_nDocID( 0 )
{
osl_createThread(workerfunc, this);
}
GrammarCheckingIterator::~GrammarCheckingIterator()
{
}
//create new DocID
const ::sal_Int32 GrammarCheckingIterator::NextDocId()
{
osl::Guard< osl::Mutex > aGuard(GetMutex());
m_nDocID += 1;
return m_nDocID;
}
lang::Locale getPrimaryLanguageOfSentence( uno::Reference< text::XFlatParagraph > xFlatPara, sal_Int32 nStartIndex )
{
(void) nStartIndex;
//get the language of the first word
return xFlatPara->getLanguageOfText(nStartIndex, 1);//nStartIndex
}
void GrammarCheckingIterator::AddEntry(
uno::WeakReference< text::XFlatParagraphIterator > xFlatParaIterator,
uno::WeakReference< text::XFlatParagraph > xFlatPara,
sal_Int32 nDocID,
sal_Int32 nStartIndex,
sal_Bool bAutomatic )
{
osl::Guard< osl::Mutex > aGuard(GetMutex());
FPEntry aNewFPEntry;
aNewFPEntry.m_xParaIterator = xFlatParaIterator;
aNewFPEntry.m_xPara = xFlatPara;
aNewFPEntry.m_nDocID = nDocID;
aNewFPEntry.m_nStartIndex = nStartIndex;
aNewFPEntry.m_bAutomatic = bAutomatic;
// add new entry to the end of this queue
m_aFPQueue.push_back(aNewFPEntry);
// wake up the thread in order to do grammar checking
m_aCondition.set();
}
//doGrammarChecking_Impl
void GrammarCheckingIterator::doGrammarChecking_Impl(
sal_Int32 nDocId,
const uno::Reference< text::XFlatParagraph > & xFlatPara,
const lang::Locale & rLocale,
sal_Int32 nStartOfSentencePos,
sal_Int32 nSuggestedSentenceEndPos)
{
//check the locale
/*if(m_aGCLocales.size() == 0)
{
GetAvailableGCSvcs_Impl();
}
for (GCLocales_t::const_iterator it = m_aGCLocales.begin(); it != m_aGCLocales.end(); ++ it)
{
uno::Sequence< lang::Locale > aLocales = it->second;
for (sal_Int32 i=0; i<aLocales.getLength(); ++i)
{
if( MsLangId::convertLocaleToLanguage(aLocales[i]) == MsLangId::convertLocaleToLanguage(rLocale))
{
GrammarChecker* pGC=new GrammarChecker();
pGC->addGrammarCheckingResultListener((XGrammarCheckingResultListener *) this);
pGC->doGrammarChecking(nDocId, xFlatPara, rLocale, nStartOfSentencePos, nSuggestedSentenceEndPos);//rFlatParaText
break;
}
}
}*/
GrammarChecker* pGC=new GrammarChecker();
pGC->addGrammarCheckingResultListener((XGrammarCheckingResultListener *) this);
pGC->doGrammarChecking(nDocId, xFlatPara, rLocale, nStartOfSentencePos, nSuggestedSentenceEndPos);//rFlatParaText
}
//get every element from the queue and check it
void GrammarCheckingIterator::dequeueAndCheck()
{
// ---- THREAD SAFE START ----
osl::ResettableGuard< osl::Mutex > aGuard(GetMutex());
bool bEnd( m_bEnd );
aGuard.clear();
// ---- THREAD SAFE END ----
while( !bEnd )
{
// ---- THREAD SAFE START ----
aGuard.reset();
bool bQueueEmpty = m_aFPQueue.empty();
aGuard.clear();
// ---- THREAD SAFE END ----
if( !bQueueEmpty )
{
// ---- THREAD SAFE START ----
aGuard.reset();
FPEntry aFPEntryItem = m_aFPQueue.front();
uno::Reference< text::XFlatParagraphIterator > xFPIterator( uno::Reference< text::XFlatParagraphIterator >( aFPEntryItem.m_xParaIterator ), uno::UNO_QUERY);
uno::Reference< text::XFlatParagraph > xFlatPara( uno::Reference< text::XFlatParagraph >( aFPEntryItem.m_xPara ), uno::UNO_QUERY );
if(xFlatPara.is())
{
OUString aCurTxt = xFlatPara->getText();
sal_Int32 nEndPos=aCurTxt.getLength();
lang::Locale aCurLocale=getPrimaryLanguageOfSentence(xFlatPara, 0);
sal_Int32 nCurDocID=aFPEntryItem.m_nDocID;
sal_Int32 nStartPos=aFPEntryItem.m_nStartIndex;
while(nStartPos<nEndPos)
{
sal_Int32 nCurEndPos=getSuggestedEndOfSentence( aCurTxt, nStartPos, aCurLocale);
////////////////////////////////////////////////
//..............doGrammarChecking...............
////////////////////////////////////////////////
doGrammarChecking_Impl(nCurDocID, xFlatPara, aCurLocale, nStartPos, nCurEndPos);
nStartPos=nCurEndPos+1;
//update the startIndex of the entry
aFPEntryItem.m_nStartIndex=nStartPos;
m_aFPQueue.pop_front();
m_aFPQueue.push_front(aFPEntryItem);
}
//remove the first element from the queue
m_aFPQueue.pop_front();
if(xFlatPara->isModified( ))
{
//there is something unprocessed left in the current flat paragraph
//add this flat paragraph to the end of the queue
AddEntry( xFPIterator, xFlatPara, nCurDocID, 0, aFPEntryItem.m_bAutomatic );
}
else
{
//set "alread checked" flag for the current flat paragraph
//get the next flat paragraph to create a new entry
xFlatPara->setChecked(text::TextMarkupType::GRAMMAR, true);
uno::Reference< text::XFlatParagraph > xFlatParaNext = xFPIterator->getNextPara( );//getParaAfter( xFlatPara );//
if( xFlatParaNext.is() )
{
AddEntry(xFPIterator, xFlatParaNext, nCurDocID, 0, aFPEntryItem.m_bAutomatic);
}
}
}
aGuard.clear();
// ---- THREAD SAFE END ----
}
else
{
// ---- THREAD SAFE START ----
aGuard.reset();
// Check queue state again
if ( m_aFPQueue.empty() )
m_aCondition.reset();
aGuard.clear();
// ---- THREAD SAFE END ----
//if the queue is empty
// IMPORTANT: Don't call condition.wait() with locked
// mutex. Otherwise you would keep out other threads
// to add entries to the queue! A condition is thread-
// safe implemented.
m_aCondition.wait();
}
// ---- THREAD SAFE START ----
aGuard.reset();
bEnd = m_bEnd;
aGuard.clear();
// ---- THREAD SAFE END ----
}
}
// linguistic2::XGrammarCheckingIterator:
void SAL_CALL GrammarCheckingIterator::startGrammarChecking(
const uno::Reference< ::uno::XInterface > & xDoc,
const uno::Reference< text::XFlatParagraphIteratorProvider > & xIteratorProvider,
::sal_Bool bAutomatic)
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
(void) xDoc;
/******************************************************************
Add a returned value for this function????
*******************************************************************/
// TODO: Insert your implementation for "startGrammarChecking" here.
// Create new entry and push it to the global queue
osl::Guard< osl::Mutex > aGuard(GetMutex());
uno::Reference<text::XFlatParagraphIterator> xFPIterator=
xIteratorProvider->getFlatParagraphIterator(
text::TextMarkupType::GRAMMAR,bAutomatic);
uno::Reference< text::XFlatParagraph > xPara= xFPIterator->getFirstPara();
if(xPara.is())
{
::sal_Int32 nDocID = NextDocId();
m_aDocMap[xDoc]=nDocID;
AddEntry(xFPIterator, xPara, nDocID, 0, bAutomatic);
}
}
void SAL_CALL GrammarCheckingIterator::checkGrammarAtPos(
const uno::Reference< ::uno::XInterface > & xDoc,
const uno::Reference< text::XFlatParagraph > & xStartPara,
sal_Int32 nPosInPara)
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
// TODO: Insert your implementation for "checkGrammarAtPos" here.
//for the context menu
OUString aTxt = xStartPara->getText();
//sal_Int32 nEndPos=rTxt.getLength();
lang::Locale aLocale=getPrimaryLanguageOfSentence(xStartPara, nPosInPara);
uno::Reference< i18n::XBreakIterator > xBreakIterator;
if(!xBreakIterator.is())
{
xBreakIterator=vcl::unohelper::CreateBreakIterator();
}
if(xBreakIterator.is())
{
sal_Int32 nStartPosition=xBreakIterator->beginOfSentence(aTxt, nPosInPara, aLocale);;
sal_Int32 nEndPosition=xBreakIterator->endOfSentence(aTxt, nStartPosition, aLocale);
////////////////////////////////////////////////
//..............doGrammarChecking...............
////////////////////////////////////////////////
sal_Int32 nDocID=m_aDocMap[xDoc];
doGrammarChecking_Impl(nDocID, xStartPara, aLocale, nStartPosition, nEndPosition);//aTxt
}
}
sal_Int32 GrammarCheckingIterator::getSuggestedEndOfSentence( const OUString aText, sal_Int32 nSentenceStartPos, const lang::Locale aLocale )
{
// TODO: Exchange the default return implementation for "getEndOfSentence" !!!
// Exchange the default return implementation.
// NOTE: Default initialized polymorphic structs can cause problems because of
// missing default initialization of primitive types of some C++ compilers or
// different Any initialization in Java and C++ polymorphic structs.
uno::Reference< i18n::XBreakIterator > xBreakIterator;
if(!xBreakIterator.is())
{
xBreakIterator=vcl::unohelper::CreateBreakIterator();
}
sal_Int32 nEndPosition=0;
if(xBreakIterator.is())
{
nEndPosition=xBreakIterator->endOfSentence(aText, nSentenceStartPos, aLocale);
}
return nEndPosition;
}
sal_Int32 SAL_CALL GrammarCheckingIterator::getEndOfSentence( sal_Int32 nSentenceStartPos )
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
// TODO: Exchange the default return implementation for "getEndOfSentence" !!!
// Exchange the default return implementation.
// NOTE: Default initialized polymorphic structs can cause problems because of
// missing default initialization of primitive types of some C++ compilers or
// different Any initialization in Java and C++ polymorphic structs.
(void)nSentenceStartPos;
/*uno::Reference< i18n::XBreakIterator > xBreakIterator;
if(!xBreakIterator.is())
{
xBreakIterator=vcl::unohelper::CreateBreakIterator();
}
sal_Int32 nEndPosition=0;
if(xBreakIterator.is())
{
struct FPEntry aNewFPEntry=m_aFPQueue.front();
uno::Reference< text::XFlatParagraph > xFlatPara( uno::Reference< text::XFlatParagraph >( aNewFPEntry.xPara ), uno::UNO_QUERY );
if(xFlatPara.is())
{
OUString aCurTxt = xFlatPara->getText();
lang::Locale aCurLocale=getPrimaryLanguageOfSentence(xFlatPara, 0);
nEndPosition=xBreakIterator->endOfSentence(aCurTxt, nSentenceStartPos, aCurLocale);
}
}
return nEndPosition;*/
return 0;
}
::sal_Bool SAL_CALL GrammarCheckingIterator::isChecking( const uno::Reference< ::uno::XInterface > & xDoc )
throw (uno::RuntimeException)
{
// TODO: Exchange the default return implementation for "isChecking" !!!
// Exchange the default return implementation.
// NOTE: Default initialized polymorphic structs can cause problems because of
// missing default initialization of primitive types of some C++ compilers or
// different Any initialization in Java and C++ polymorphic structs.
osl::Guard< osl::Mutex > aGuard(GetMutex());
sal_Bool bCheck=sal_False;
if(m_aDocMap.find(xDoc) != m_aDocMap.end())
{
sal_Int32 nDocID = m_aDocMap[xDoc];
if(!m_aFPQueue.empty())
{
sal_Int32 nSize = m_aFPQueue.size();
for( sal_Int32 i=0; i < nSize; ++i )
{
FPEntry aNewFPEntry = m_aFPQueue[i];
if( nDocID == aNewFPEntry.m_nDocID )
{
return true;
}
}
}
}
return bCheck;
}
// linguistic2::XGrammarCheckingResultListener:
::sal_Bool SAL_CALL GrammarCheckingIterator::GrammarCheckingFinished( const linguistic2::GrammarCheckingResult & aRes )
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
// TODO: Exchange the default return implementation for "GrammarCheckingFinished" !!!
// Exchange the default return implementation.
// NOTE: Default initialized polymorphic structs can cause problems because of
// missing default initialization of primitive types of some C++ compilers or
// different Any initialization in Java and C++ polymorphic structs.
//mark the error sign
uno::Sequence< linguistic2::SingleGrammarError > aErrors=aRes.aGrammarErrors;
if(aErrors.getLength()>0)
{
for( sal_Int16 i=0; i < aErrors.getLength(); ++i)
{
linguistic2::SingleGrammarError aError = aErrors[aErrors.getLength()-1-i];
///////////////////////////////////////////////////////////////////////////////////////////////
//spelling checkers and grammar checkers spontaneously simultaneously check the same sentence//
//linguistic::GetLinguProperties()????????????????????????????????????????????????????????????
///////////////////////////////////////////////////////////////////////////////////////////////
uno::Sequence< beans::PropertyValue > aAttributes;
OUString aIdentifier;
uno::Reference< container::XStringKeyMap > xStringKeyMap;
//display the grammar error mark
aRes.xPara->commitTextMarkup(aError.nErrorType, aIdentifier ,aError.nErrorStart ,aError.nErrorLen, xStringKeyMap);
}
}
sal_Bool bResult=aRes.nEndOfSentencePos < aRes.xPara->getText().getLength();
aRes.xPara->setChecked(text::TextMarkupType::GRAMMAR, bResult);
return bResult;
}
/*// linguistic2::XGrammarCheckingResultListener:
void SAL_CALL GrammarCheckingIterator::processGrammarCheckingResult(
com::sun::star::linguistic2::GrammarCheckingResult aRes,
sal_Bool bLastInCurrentPara)
throw (uno::RuntimeException)
{
(void) aRes;
(void) bLastInCurrentPara;
}*/
void SAL_CALL GrammarCheckingIterator::dispose( ) throw (uno::RuntimeException)
{
}
void SAL_CALL GrammarCheckingIterator::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
throw (uno::RuntimeException)
{
(void) xListener;
}
void SAL_CALL GrammarCheckingIterator::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
throw (uno::RuntimeException)
{
(void) xListener;
}
const void GrammarCheckingIterator::GetAvailableGCSvcs_Impl()
{
uno::Reference< lang::XMultiServiceFactory > xFac( getProcessServiceFactory() );
if (xFac.is())
{
uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xFac, uno::UNO_QUERY );
uno::Reference< container::XEnumeration > xEnum;
if (xEnumAccess.is())
xEnum = xEnumAccess->createContentEnumeration(
A2OU( "com.sun.star.lingu2.GrammarChecker" ) );//SN_SPELLCHECKER
if (xEnum.is())
{
while (xEnum->hasMoreElements())
{
uno::Any aCurrent = xEnum->nextElement();
uno::Reference< lang::XSingleServiceFactory > xFactory;
if (!::cppu::extractInterface( xFactory, aCurrent ))
continue;
uno::Reference< linguistic2::XGrammarChecker > xSvc( xFactory->createInstance(), uno::UNO_QUERY );
if (xSvc.is())
{
OUString aImplName;
//uno::Sequence< INT16 > aLanguages;
uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY );
if (xInfo.is())
aImplName = xInfo->getImplementationName();
DBG_ASSERT( aImplName.getLength(),
"empty implementation name" );
uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY );
DBG_ASSERT( xSuppLoc.is(), "interfaces not supported" );
if (xSuppLoc.is()) {
uno::Sequence< lang::Locale > aLocaleSequence(xSuppLoc->getLocales());
m_aGCLocales[aImplName]=aLocaleSequence;
//aLanguages = LocaleSeqToLangSeq( aLocaleSequence );
}
//pAvailSpellSvcs->Insert( new SvcInfo( aImplName, aLanguages ),
// pAvailSpellSvcs->Count() );
//m_aGCLocales[aImplName]=aLocaleSequence;//aLanguages;
}
}
}
}
}
sal_Bool SAL_CALL GrammarCheckingIterator::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard(GetMutex());
uno::Sequence< OUString > aSNL = getSupportedServiceNames();
const OUString * pArray = aSNL.getConstArray();
for( INT32 i = 0; i < aSNL.getLength(); ++i )
if( pArray[i] == ServiceName )
return TRUE;
return FALSE;
}
uno::Sequence< OUString > GrammarCheckingIterator::getSupportedServiceNames_Static() throw()
{
//osl::Guard< osl::Mutex > aGuard(GetMutex());
uno::Sequence< OUString > aSNS( 1 ); // auch mehr als 1 Service moeglich
aSNS.getArray()[0] = A2OU( "com.sun.star.linguistic2.GrammarCheckingIterator" );//SN_LINGU_SERVCICE_MANAGER
return aSNS;
}
uno::Sequence< OUString > SAL_CALL GrammarCheckingIterator::getSupportedServiceNames() throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard(GetMutex());
return getSupportedServiceNames_Static();
}
OUString SAL_CALL GrammarCheckingIterator::getImplementationName() throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard(GetMutex());
return getImplementationName_Static();
}
sal_Bool SAL_CALL GrammarCheckingIterator_writeInfo( void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey )
{
try
{
String aImpl( '/' );
aImpl += GrammarCheckingIterator::getImplementationName_Static().getStr();
aImpl.AppendAscii( "/UNO/SERVICES" );
uno::Reference< registry::XRegistryKey > xNewKey =
pRegistryKey->createKey( aImpl );
uno::Sequence< OUString > aServices = GrammarCheckingIterator::getSupportedServiceNames_Static();
for( INT32 i = 0; i < aServices.getLength(); ++i )
xNewKey->createKey( aServices.getConstArray()[i] );
return sal_True;
}
catch(uno::Exception &)
{
return sal_False;
}
}
uno::Reference< uno::XInterface > SAL_CALL GrammarCheckingIterator_CreateInstance(
const uno::Reference< lang::XMultiServiceFactory > & /*rSMgr*/ )
throw(uno::Exception)
{
uno::Reference< uno::XInterface > xService = (cppu::OWeakObject*) new GrammarCheckingIterator;
return xService;
}
void * SAL_CALL GrammarCheckingIterator_getFactory(
const sal_Char * pImplName,
lang::XMultiServiceFactory * pServiceManager,
void * /*pRegistryKey*/ )
{
void * pRet = 0;
if ( !GrammarCheckingIterator::getImplementationName_Static().compareToAscii( pImplName ) )
{
uno::Reference< lang::XSingleServiceFactory > xFactory =
cppu::createOneInstanceFactory(
pServiceManager,
GrammarCheckingIterator::getImplementationName_Static(),
GrammarCheckingIterator_CreateInstance,
GrammarCheckingIterator::getSupportedServiceNames_Static());
// acquire, because we return an interface pointer instead of a reference
xFactory->acquire();
pRet = xFactory.get();
}
return pRet;
}
Reference in a new issue View git blame Copy permalink