gebe
  1. SadmiN

    SadmiN ♥ Ölürüm Sana Mavimm ♥ Yetkili Kişi

    Kayıt:
    29 Mayıs 2007
    Mesajlar:
    15.365
    Beğenilen Mesajlar:
    960
    Ödül Puanları:
    113

    Xenforo Türkçe karakter sorunu

    Konu, 'Xenforo' kısmında SadmiN tarafından paylaşıldı.

    Xenforo türkçe karakter sorununu nasıl halledebilirim ? Xenforo Ç Ö Ü Ş gibi harflerin görünmemesini nasıl sağlarım?
    Merhabalar değerli arkadaşlarım. Türkiye'nin en büyük kadın sitelerinden birisi olarak vbullettin forum bölümünü biliyorsunuz xenforo olarak yeniden convert ettik ve kullanmaya başladık. Çokta hoşumuza gittiğini söyleyebiliriz.

    Şimdi konu açtığınızda içerisinde türkçe harfler var ise hem link garip çıkıyor hemde linki bir yerde paylaştığınız zaman yüzde işaretlerine benzer bir takım şekiller çıkıyor. Bunun seo yada google açısından öncelikle hiç bir şekilde sakınca taşımadığının altını çizmek istiyorum. Vbseo daki karakter url lerini;

    LİBRARY>>>>XENFORO>>>>> link.php dosyasına entegre ederek bu sorundan kurtulabilmeniz mümkün olacaktır.

    Xenforo 1.2.0 kararlı sürüm için kendimde editlediğim link.php dosyasının kod içeriği aynen aşağıdaki şekildeki gibidir. Sizlerde ilgili dosyayı açarak aşağıdaki kodların tamamını ilgili dosya içindeki kodları silerek yapıştırıp kayıt ederseniz sıkıntı olan karakterler düzelecektir.

    Saygılar sunuyorum.

    NOT: İLGİLİ BU DOSYA 22.07.2015 TARİHİNDE XENFORO 1.4.9 VERSİYONUNA GÖRE DÜZENLENMİŞTİR AYNI ZAMANDA AŞAĞIDAN DA İNDİREBİLİRSİNİZ.
    KOD OLARAK EKLENEN TÜM YAPIYI LİNK.PHP DOSYASINA KOPYALAYIP YAPIŞTIRARAK TA KULLANABİLİRSİNİZ.


    AYRICA Link.php dosyasını >>>>>>> TIKLAYARAKTA İNDİREBİLİRSİNİZ

    PHP:
    <?php
    /**
     * Helper methods to generate links to content. Links generated
     * by this are not necessarily HTML escaped. The calling code
     * should escape them for the output context they apply to.
     *
     * @package XenForo_Core
     */
    class XenForo_Link
    {
        
    /**
        * Stores a cache of handlers for prefixes. Many types of links will
        * be generated multiple times on a page, so this cache reduces the
        * amount of object creation/validation necessary.
        *
        * @var array
        */
        
    protected static $_handlerCache = array();
        
    /**
        * URL prefix to use when generating a canonical link.
        *
        * @var string|null
        */
        
    protected static $_canonicalLinkPrefix null;
        
    /**
        * If true, uses friendly URLs that don't include index.php or a query string (unless required).
        *
        * @var boolean
        */
        
    protected static $_useFriendlyUrls false;
        
    /**
        * If true, Romanize titles before outputting them in URLs.
        *
        * @var boolean
        */
        
    protected static $_romanizeTitles false;
        protected static 
    $_includeTitlesInUrls true;
        protected static 
    $_routeFiltersOut = array();
        
    /**
        * @var string
        */
        
    protected static $_indexRoute 'forums/';
        protected 
    $_linkString '';
        protected 
    $_canPrependFull true;
        
    /**
        * Constructor. Use the static methods in general. However, you can create
        * an object of this type from a link builder to generate an arbitrary URL.
        *
        * @param string $linkString
        * @param boolean $canPrependFull True if the default full link prefix can be prepended to make a full URL
        */
        
    public function __construct($linkString$canPrependFull true)
        {
            
    $this->_linkString $linkString;
            
    $this->_canPrependFull $canPrependFull;
        }
        
    /**
        * @return string Link
        */
        
    public function __toString()
        {
            return 
    $this->_linkString;
        }
        
    /**
        * @return boolean
        */
        
    public function canPrependFull()
        {
            return 
    $this->_canPrependFull;
        }
        
    /**
        * Builds a link to a public resource. The type should contain a prefix
        * optionally split by a "/" with the specific action (eg "templates/edit").
        *
        * @param string $type Prefix and action
        * @param mixed $data Data that the prefix/action should be applied to, if applicable
        * @param array $extraParams Additional params
        *
        * @return string The link
        */
        
    public static function buildPublicLink($type$data null, array $extraParams = array(), $skipPrepend false)
        {
            
    $type self::_checkForFullLink($type$fullLink$fullLinkPrefix);
            
    $link self::_buildLink('public'$type$data$extraParams$prefix);
            
    $queryString self::buildQueryString($extraParams);
            if (
    $link instanceof XenForo_Link)
            {
                
    $isRaw true;
                
    $canPrependFull $link->canPrependFull();
            }
            else
            {
                
    $isRaw false;
                
    $canPrependFull true;
                if (
    strpos($link'#') !== false)
                {
                    list(
    $link$hash) = explode('#'$link);
                }
                if (
    $link == self::$_indexRoute)
                {
                    
    $link '';
                }
                else if (isset(
    self::$_routeFiltersOut[$prefix]))
                {
                    foreach (
    self::$_routeFiltersOut[$prefix] AS $filter)
                    {
                        list(
    $from$to) = self::translateRouteFilterToRegex(
                            
    $filter['find_route'], $filter['replace_route']
                        );
                        
    $newLink preg_replace($from$to$link);
                        if (
    $newLink != $link)
                        {
                            
    $link $newLink;
                            break;
                        }
                    }
                }
            }
            if (
    self::$_useFriendlyUrls || $isRaw)
            {
                
    $outputLink = ($queryString !== '' "$link?$queryString$link);
            }
            else
            {
                if (
    $queryString !== '' && $link !== '')
                {
                    
    $append "?$link&$queryString";
                }
                else
                {
                    
    // 1 or neither of these has content
                    
    $append $link $queryString;
                    if (
    $append !== '')
                    {
                        
    $append "?$append";
                    }
                }
                if (
    $skipPrepend)
                {
                    
    $outputLink $append;
                }
                else
                {
                    
    $outputLink 'index.php' .  $append;
                }
            }
            if (
    $fullLink && $canPrependFull)
            {
                
    $outputLink $fullLinkPrefix $outputLink;
            }
            
    // deal with a hash in the $type {xen:link prefix#hash..}
            
    if (($hashPos strpos($type'#')) !== false)
            {
                
    $hash substr($type$hashPos 1);
            }
            if (
    $outputLink === '')
            {
                
    $outputLink '.';
            }
            return 
    $outputLink . (empty($hash) ? '' '#' $hash);
        }
        
    /**
        * Builds a link to an admin resource. The type should contain a prefix
        * optionally split by a "/" with the specific action (eg "templates/edit").
        *
        * @param string $type Prefix and action
        * @param mixed $data Data that the prefix/action should be applied to, if applicable
        * @param array $extraParams Additional params
        *
        * @return string The link
        */
        
    public static function buildAdminLink($type$data null, array $extraParams = array())
        {
            
    $type self::_checkForFullLink($type$fullLink$fullLinkPrefix);
            
    $link self::_buildLink('admin'$type$data$extraParams);
            
    $queryString self::buildQueryString($extraParams);
            if (
    strpos($link'#') !== false)
            {
                list(
    $link$hash) = explode('#'$link);
            }
            if (
    $queryString !== '' && $link !== '')
            {
                
    $append $link '&' $queryString;
            }
            else
            {
                
    // 1 or neither of these has content
                
    $append $link $queryString;
            }
            
    // deal with a hash in the $type {xen:link prefix#hash..}
            
    if (($hashPos strpos($type'#')) !== false)
            {
                
    $append .= substr($type$hashPos 1);
            }
            
    $outputLink 'admin.php' . ($append !== '' '?' '') . $append;
            if (
    $fullLink)
            {
                
    $outputLink $fullLinkPrefix $outputLink;
            }
            return 
    $outputLink . (empty($hash) ? '' '#' $hash);
        }
        
    /**
        * Builds a link along the lines of <prefix>/<sub-component>/<data.id>/<action>.
        *
        * @param array $subComponents List of sub-components that are valid as keys, with specific child keys (title, intId, stringId)
        * @param string $outputPrefix
        * @param string $action
        * @param string $extension
        * @param mixed $data
        *
        * @return string|false String if sub-component matched with appropriate data, false otherwise
        */
        
    public static function buildSubComponentLink(array $subComponents$outputPrefix$action$extension$data)
        {
            
    $parts explode('/'$action2);
            
    $subComponentName strtolower($parts[0]);
            foreach (
    $subComponents AS $key => $subComponent)
            {
                if (
    $key == $subComponentName)
                {
                    
    $action = (isset($parts[1]) ? $parts[1] : '');
                    if (isset(
    $subComponent['intId']))
                    {
                        
    $titleField = (isset($subComponent['title']) ? $subComponent['title'] : '');
                        return 
    self::buildBasicLinkWithIntegerParam("$outputPrefix/$parts[0]"$action$extension$data$subComponent['intId'], $titleField);
                    }
                    else if (isset(
    $subComponent['stringId']))
                    {
                        return 
    self::buildBasicLinkWithStringParam("$outputPrefix/$parts[0]"$action$extension$data$subComponent['stringId']);
                    }
                    else
                    {
                        return 
    false;
                    }
                }
            }
            return 
    false;
        }
        
    /**
        * Check to see if a full link is requested.
        *
        * @param string $type Link type
        * @param boolean $fullLink Modified by ref. Returns whether a full link is requested.
        * @param string $fullLinkPrefix If a full link is requested, the prefix to use
        *
        * @return string Link type, with full link param stripped off if necessary
        */
        
    protected static function _checkForFullLink($type, &$fullLink, &$fullLinkPrefix)
        {
            if (!
    $type)
            {
                
    $fullLink false;
                
    $fullLinkPrefix '';
                return 
    $type;
            }
            if (
    $type[0] == 'c' && substr($type010) == 'canonical:')
            {
                
    $type substr($type10);
                
    $fullLink true;
                
    $fullLinkPrefix self::getCanonicalLinkPrefix() . '/';
            }
            else if (
    $type[0] == 'f' && substr($type05) == 'full:')
            {
                
    $type substr($type5);
                
    $fullLink true;
                
    $paths XenForo_Application::get('requestPaths');
                
    $fullLinkPrefix $paths['fullBasePath'];
            }
            else
            {
                
    $fullLink false;
                
    $fullLinkPrefix '';
            }
            return 
    $type;
        }
        
    /**
        * Internal link builder.
        *
        * @param string $group Type of link being built (admin or public)
        * @param string $type Type of data the link is for (prefix and action)
        * @param mixed $data
        * @param array $extraParams
        * @param string|null $prefix The prefix found
        *
        * @return string
        */
        
    protected static function _buildLink($group$type$data, array &$extraParams, &$prefix null)
        {
            if (isset(
    $extraParams['_params']) && is_array($extraParams['_params']))
            {
                
    $params $extraParams['_params'];
                unset(
    $extraParams['_params']);
                
    $extraParams array_merge($params$extraParams);
            }
            
    $extension '';
            if ((
    $dotPos strrpos($type'.')) !== false)
            {
                
    $extension substr($type$dotPos 1);
                
    $type substr($type0$dotPos);
            }
            if ((
    $hashPos strpos($type'#')) !== false)
            {
                
    $type substr($type0$hashPos);
            }
            if ((
    $slashPos strpos($type'/')) !== false)
            {
                list(
    $prefix$action) = explode('/'$type2);
                if (
    $action == 'index')
                {
                    
    $action '';
                }
            }
            else
            {
                
    $prefix $type;
                
    $action '';
            }
            unset(
    $type);
            
    $handler self::_getPrefixHandler($group$prefix, (boolean)$data);
            if (
    $handler === false)
            {
                
    $link false;
            }
            else
            {
                
    $link $handler->buildLink($prefix$prefix$action$extension$data$extraParams);
            }
            if (
    $link === false || $link === null)
            {
                return 
    self::buildBasicLink($prefix$action$extension);
            }
            else
            {
                return 
    $link;
            }
        }
        
    /**
        * Gets the object that should handle building the link for this prefix.
        * May also return false if only the standard behavior is desired.
        *
        * @param string $group Type of link (public or admin)
        * @param string $originalPrefix Prefix to build the link for (should be the "original prefix" in the DB)
        * @param boolean $haveData Whether we have a data element
        *
        * @return object|false Object with "buildLink" method or false
        */
        
    protected static function _getPrefixHandler($group$originalPrefix$haveData)
        {
            if (!isset(
    self::$_handlerCache[$group]))
            {
                
    self::$_handlerCache[$group] = self::_loadHandlerInfoForGroup($group);
            }
            if (!isset(
    self::$_handlerCache[$group][$originalPrefix]))
            {
                return 
    false;
            }
            
    $info =& self::$_handlerCache[$group][$originalPrefix];
            if (
    $haveData)
            {
                if (!isset(
    $info['handlerWithData']))
                {
                    
    $info['handlerWithData'] = self::_loadPrefixHandlerClass($infotrue);
                }
                return 
    $info['handlerWithData'];
            }
            else
            {
                if (!isset(
    $info['handlerNoData']))
                {
                    
    $info['handlerNoData'] = self::_loadPrefixHandlerClass($infofalse);
                }
                return 
    $info['handlerNoData'];
            }
        }
        
    /**
        * Load the prefix link build handler class based on current settings.
        *
        * @param array $info Info about how to build this link (includes build_link, route_class keys)
        * @param boolean $haveData True if we have a data param for this link
        *
        * @return object|false Object with "buildLink" method or false
        */
        
    protected static function _loadPrefixHandlerClass(array $info$haveData)
        {
            if (
    $info['build_link'] == 'none' || ($info['build_link'] == 'data_only' && !$haveData))
            {
                
    // never build or only build when we have data (and we don't now)
                
    return false;
            }
            if (
    $info['build_link'] == 'all')
            {
                
    // always build - check for a previous call
                
    if (isset($info['handlerWithData']))
                {
                    return 
    $info['handlerWithData'];
                }
                else if (isset(
    $info['handlerNoData']))
                {
                    return 
    $info['handlerNoData'];
                }
            }
            
    // ...otherwise load the class we need
            
    $class XenForo_Application::resolveDynamicClass($info['route_class'], 'route_prefix');
            if (!
    $class)
            {
                return 
    false;
            }
            
    $handler = new $class();
            if (!
    method_exists($handler'buildLink'))
            {
                return 
    false;
            }
            return 
    $handler;
        }
        
    /**
        * Loads all the link build handler data for an entire group of prefixes.
        *
        * @param string $group Type of prefix (public or admin)
        *
        * @return array Keys are "original prefixes" and values are info about output prefix/class/build settings
        */
        
    protected static function _loadHandlerInfoForGroup($group)
        {
            return 
    XenForo_Model::create('XenForo_Model_RoutePrefix')->getPrefixesForRouteCache($group);
        }
        
    /**
        * Gets the name of the specified prefix handler class.
        *
        * @param string $group
        * @param string $prefix
        *
        * @return string|false
        */
        
    public static function getPrefixHandlerClassName($group$prefix)
        {
            if (!isset(
    self::$_handlerCache[$group]))
            {
                
    self::$_handlerCache[$group] = self::_loadHandlerInfoForGroup($group);
            }
            if (!isset(
    self::$_handlerCache[$group][$prefix]))
            {
                return 
    false;
            }
            return 
    self::$_handlerCache[$group][$prefix]['route_class'];
        }
        
    /**
        * Examines action and extra parameters from a link build call and formulates
        * a page number link parameter if applicable.
        *
        * @param string $action
        * @param array $params
        *
        * @return string $action
        */
        
    public static function getPageNumberAsAction($action, array &$params)
        {
            if (isset(
    $params['page']))
            {
                if (
    strval($params['page']) !== XenForo_Application::$integerSentinel && $params['page'] <= 1)
                {
                    unset(
    $params['page']);
                }
                else if (!
    $action)
                {
                    if (
    $params['page'] != XenForo_Application::$integerSentinel)
                    {
                        
    $params['page'] = intval($params['page']);
                    }
                    
    $action "page-$params[page]";
                    unset(
    $params['page']);
                }
            }
            return 
    $action;
        }
        
    /**
        * Helper to manually set handler info for a group. Keys should be "original prefixes"
        * and values should be arrays with keys matching the xf_route_prefix table.
        *
        * @param string $group Type of prefix to handle (public or admin)
        * @param array $info Info to set
        */
        
    public static function setHandlerInfoForGroup($group, array $info)
        {
            
    self::$_handlerCache[$group] = $info;
        }
        
    /**
        * Gets the handler info for the group of prefixes.
        *
        * @param string $group
        *
        * @return array
        */
        
    public static function getHandlerInfoForGroup($group)
        {
            if (!isset(
    self::$_handlerCache[$group]))
            {
                
    self::$_handlerCache[$group] = self::_loadHandlerInfoForGroup($group);
            }
            return 
    self::$_handlerCache[$group];
        }
        
    /**
        * Resets the handlers for all groups or for a particular group. Mainly used for testing.
        *
        * @param string|false $group If false, resets all handlers; otherwise, resets the specified handler group
        */
        
    public static function resetHandlerInfo($group false)
        {
            if (
    $group === false)
            {
                
    self::$_handlerCache = array();
            }
            else
            {
                unset(
    self::$_handlerCache[strval($group)]);
            }
        }
        
    /**
        * Builds a basic link: a prefix and action only.
        *
        * @param string $prefix
        * @param string $action
        * @param string $extension
        *
        * @return string
        */
        
    public static function buildBasicLink($prefix$action$extension '')
        {
            if (
    $extension)
            {
                
    self::prepareExtensionAndAction($extension$action);
            }
            if (
    $prefix === 'index' && $action === '')
            {
                return 
    '';
            }
            else
            {
                return 
    "$prefix/$action$extension";
            }
        }
        
    /**
        * Prepares the link extension and action, if necessary. If an extension is specified,
        * the provided value will be prefixed with a ".". If there is an extension and there's
        * no action, an explicit "index" action will be specified.
        *
        * @param string $extension Initially, the extension to the link specified; prefixed with "." if necessary
        * @param string $action The link action; modified if necessary
        */
        
    public static function prepareExtensionAndAction(&$extension, &$action$prepareAction true)
        {
            if (
    $extension)
            {
                
    $extension '.' $extension;
                if (
    $action === '')
                {
                    
    $action 'index';
                }
            }
        }
        
    /**
        * Builds a basic link for a request that may have an integer param.
        * Output will be in the format [prefix]/[title].[int]/[action]/ or similar,
        * based on whether the correct values in data are set.
        *
        * @param string $prefix Link prefix
        * @param string $action Link action
        * @param string $extension Link extension (for content type)
        * @param mixed $data Specific data to link to. If available, an array or an object that implements ArrayAccess
        * @param string $intField The name of the field that holds the integer identifier
        * @param string $titleField If there is a title field, the name of the field that holds the title
        *
        * @return false|string False if no data is provided, the link otherwise
        */
        
    public static function buildBasicLinkWithIntegerParam($prefix$action$extension$data$intField$titleField '')
        {
            if ((
    is_array($data) || $data instanceof ArrayAccess) && isset($data[$intField]))
            {
                
    self::prepareExtensionAndAction($extension$action);
                
    $title = (($titleField && !empty($data[$titleField])) ? $data[$titleField] : '');
                return 
    "$prefix/" self::buildIntegerAndTitleUrlComponent($data[$intField], $title) . "/$action$extension";
            }
            else
            {
                return 
    false;
            }
        }
        
    /**
        * Builds a basic link for a request that may have a string param.
        * Output will be in the format [prefix]/[param]/[action].
        *
        * Note that it is expected that the string param is already clean enough
        * to be inserted into the link.
        *
        * @param string $prefix Link prefix
        * @param string $action Link action
        * @param string $extension Link extension (for content type)
        * @param mixed $data Specific data to link to. If available, an array or an object that implements ArrayAccess, or a simple string to be used directly
        * @param string $strField The name of the field that holds the string identifier
        *
        * @return false|string False if no data is provided, the link otherwise
        */
        
    public static function buildBasicLinkWithStringParam($prefix$action$extension$data$strField)
        {
            if (
    $data)
            {
                
    self::prepareExtensionAndAction($extension$action);
                if ((
    is_array($data) || $data instanceof ArrayAccess)
                    && isset(
    $data[$strField])
                    && 
    $data[$strField] !== '')
                {
                    return 
    "$prefix/" $data[$strField] . "/$action$extension";
                }
                else if (
    is_string($data))
                {
                    return 
    "$prefix/$data/$action$extension";
                }
            }
            return 
    false;
        }
        
    /**
        * Builds the URL component for an integer and title. Outputs <int> or <int>-<title>.
        *
        * @param integer $integer
        * @param string $title
        * @param boolean|null $romanize If true, non-latin strings are romanized. If null, use default setup
        *
        * @return string
        */
        
    public static function buildIntegerAndTitleUrlComponent($integer$title ''$romanize null)
        {
            if (
    $title && self::$_includeTitlesInUrls)
            {
                if (
    $romanize === null)
                {
                    
    $romanize self::$_romanizeTitles;
                }
                
    $title self::getTitleForUrl($title$romanize);
                if (
    $title !== '')
                {
                    
    # /item-title.id/ (where delimiter is '.')
                    
    return urlencode($title) . XenForo_Application::URL_ID_DELIMITER intval($integer);
                }
            }
            return 
    intval($integer);
        }
        
    /**
        * Cache for getting prepped/Romanized titles for URLs
        *
        * @var array
        */
        
    protected static $_titleCache = array();
        
    /**
        * Gets version of a title that is valid in a URL. Invalid elements are stripped
        * or replaced with '-'. It may not be possible to reverse a URL'd title to the
        * original title.
        *
        * @param string $title
        * @param boolean $romanize If true, non-latin strings are romanized
        *
        * @return string
        */
        
    public static function getTitleForUrl($title$romanize false)
        {
            
    $title strval($title);
            
    $lookup $title . ($romanize '|r' '');
            if (isset(
    self::$_titleCache[$lookup]))
            {
                return 
    self::$_titleCache[$lookup];
            }
           
            if (
    $romanize)
            {
                
    $title utf8_romanize(utf8_deaccent($title));
            }
            
    $title strtr(
                
    $title,
                
    '`!"$%^&*()-+={}[]<>;:@#~,./?|' "\r\n\t\\",
                
    '                             ' '    '
            
    );
            
    $title strtr($title, array(
            
    '"' => '',
            
    "'" => '',
            
    "Ö" => "o",
            
    "ö" => "o",
            
    "C" => "c",
            
    "c" => "c",
            
    "Ğ" => "g",
            
    "ğ" => "g",
            
    "Ş" => "s",
            
    "ş" => "s",
            
    "Ü" => "u",
            
    "ü" => "u",
            
    "İ" => "i",
            
    "ı" => "i",
            
    "Ç" => "c",
            
    "ç" => "c",
            
    "é" => "i",
            
    "â" => "a",
            
    "Ê" => "e",
            
    "Â" => "a",
            
    "?" => "_",
            
    "*" => "_",
            
    "." => "_",
            
    "," => "_",
            
    ";" => "_",
            
    ")" => "_",
            
    "(" => "_",
            
    "{" => "_",
            
    "}" => "_",
            
    "[" => "_",
            
    "]" => "_",
            
    "!" => "_",
            
    "+" => "_",
            
    "%" => "_",
            
    "&" => "_",
            
    "#" => "_",
            
    "$" => "_",
            
    "=" => "_",
            
    "ê" => "e",
            
    "." => "-"
            
    ));
            if (
    $romanize)
            {
                
    $title preg_replace('/[^a-zA-Z0-9_ -]/'''$title);
            }
            
    $title preg_replace('/[ ]+/''-'trim($title));
            
    $title strtr($title'ABCDEFGHIJKLMNOPQRSTUVWXYZ''abcdefghijklmnopqrstuvwxyz');
            
    self::$_titleCache[$lookup] = $title;
            return 
    $title;
        }
        
    /**
        * Builds a query string from an array of items. Keys of the array will become
        * names of items in the query string. Nested arrays are supported.
        *
        * @param array $elements Elements to build the query string from
        * @param string $prefix For nested arrays, specifies the base context we're in.
        *         Leave default unless wanting all elements inside an array.
        *
        * @return string
        */
        
    public static function buildQueryString(array $elements$prefix '')
        {
            
    $output = array();
            foreach (
    $elements AS $name => $value)
            {
                if (
    is_array($value))
                {
                    if (!
    $value)
                    {
                        continue;
                    }
                    
    $encodedName = ($prefix $prefix '[' urlencode($name) . ']' urlencode($name));
                    
    $childOutput self::buildQueryString($value$encodedName);
                    if (
    $childOutput !== '')
                    {
                        
    $output[] = $childOutput;
                    }
                }
                else
                {
                    if (
    $value === null || $value === false || $value === '')
                    {
                        continue;
                    }
                    
    $value strval($value);
                    if (
    $prefix)
                    {
                        
    // part of an array
                        
    $output[] = $prefix '[' urlencode($name) . ']=' urlencode($value);
                    }
                    else
                    {
                        
    $output[] = urlencode($name) . '=' urlencode($value);
                    }
                }
            }
            return 
    implode('&'$output);
        }
        
    /**
        * Set the prefix for links that are generated as canonical links.
        *
        * @param string $linkPrefix
        */
        
    public static function setCanonicalLinkPrefix($linkPrefix)
        {
            
    self::$_canonicalLinkPrefix self::convertUriToAbsoluteUri($linkPrefixtrue);
        }
        
    /**
        * Gets the canonical link prefix to use for generating canonical links.
        *
        * @return string
        */
        
    public static function getCanonicalLinkPrefix()
        {
            if (
    self::$_canonicalLinkPrefix === null)
            {
                
    self::$_canonicalLinkPrefix self::convertUriToAbsoluteUri(
                    
    rtrim(XenForo_Application::get('options')->boardUrl'/'),
                    
    true
                
    );
            }
            return 
    self::$_canonicalLinkPrefix;
        }
        
    /**
        * Sets whether friendly URLs should be used for generating links.
        *
        * @param boolean $value
        */
        
    public static function useFriendlyUrls($value)
        {
            
    self::$_useFriendlyUrls $value;
        }
        
    /**
        * Sets whether friendly titles should be romanized in links.
        *
        * @param boolean $value
        */
        
    public static function romanizeTitles($value)
        {
            
    self::$_romanizeTitles $value;
        }
        
    /**
        * Sets whether titles will be included in URLs
        *
        * @param boolean $value
        */
        
    public static function includeTitlesInUrls($value)
        {
            
    self::$_includeTitlesInUrls $value;
        }
        
    /**
        * Sets whether titles will be included in URLs
        *
        * @param array $value
        */
        
    public static function setRouteFiltersOut(array $value)
        {
            
    self::$_routeFiltersOut $value;
        }
        
    /**
        * Sets the index route
        *
        * @param $value
        */
        
    public static function setIndexRoute($value)
        {
            
    self::$_indexRoute $value;
        }
        
    /**
        * @return string
        */
        
    public static function getIndexRoute()
        {
            return 
    self::$_indexRoute;
        }
        
    /**
        * Converts what may be a relative link into an absolute URI.
        *
        * @param string $uri URI to convert
        * @param boolean $includeHost If true, includes host, port, and protocol
        * @param array|null $paths Paths to override (uses application level if not provided)
        *
        * @return string
        */
        
    public static function convertUriToAbsoluteUri($uri$includeHost false, array $paths null)
        {
            if (!
    $paths)
            {
                
    $paths XenForo_Application::get('requestPaths');
            }
            if (
    $uri == '.')
            {
                
    $uri ''// current directory
            
    }
            if (
    substr($uri02) == '//')
            {
                return 
    $paths['protocol'] . ':' $uri;
            }
            else if (
    substr($uri01) == '/')
            {
                if (
    $includeHost)
                {
                    return 
    $paths['protocol'] . '://' $paths['host'] . $uri;
                }
                else
                {
                    return 
    $uri;
                }
            }
            else if (
    preg_match('#^[a-z0-9-]+://#i'$uri))
            {
                return 
    $uri;
            }
            else if (
    $includeHost)
            {
                return 
    $paths['fullBasePath'] . $uri;
            }
            else
            {
                return 
    $paths['basePath'] . $uri;
            }
        }
        public static function 
    translateRouteFilterToRegex($from$to)
        {
            
    $to strtr($to, array('\\' => '\\\\''$' => '\\$'));
            
    $findReplacements = array();
            
    $replacementChr chr(26);
            
    preg_match_all('/\{([a-z0-9_]+)(:([^}]+))?\}/i'$from$matchesPREG_SET_ORDER);
            foreach (
    $matches AS $i => $match)
            {
                
    $placeholder $replacementChr $i $replacementChr;
                if (!empty(
    $match[3]))
                {
                    switch (
    $match[3])
                    {
                        case 
    'digit'$replace '(\d+)'; break;
                        case 
    'string'$replace '([^/.]+)'; break;
                        default: 
    $replace '([^/]*)';
                    }
                }
                else
                {
                    
    $replace '([^/]*)';
                }
                
    $findReplacements[$placeholder] = $replace;
                
    $from str_replace($match[0], $placeholder$from);
                
    $to str_replace($match[0], '$' . ($i 1), $to);
            }
            
    $from preg_quote($from'#');
            foreach (
    $findReplacements AS $findPlaceholder => $findReplacement)
            {
                
    $from str_replace($findPlaceholder$findReplacement$from);
            }
            return array(
    '#^' $from '#'$to);
        }
    }


     
    Son düzenleme: 22 Temmuz 2015
    guzmelegi bunu beğendi.
  2. xenforocu

    xenforocu Forum Okuru

    Merhabalar bu 1.2.2 sürümünde de çalışır mı kullanabilir miyim ?
     
  3. SadmiN

    SadmiN ♥ Ölürüm Sana Mavimm ♥ Yetkili Kişi

    Kayıt:
    29 Mayıs 2007
    Mesajlar:
    15.365
    Beğenilen Mesajlar:
    960
    Ödül Puanları:
    113
    Merhabalar,

    Evet aynı dosyayı istediğiniz sürümde ve belirttiğiniz 1.2.2 sürümünde kullanabilirsiniz. Bizde kullanıyoruz sorunsuz olarak çalışıyor.

    Saygılar.
     
Xenforo Türkçe karakter sorunu konusuna benzer diğer içeriklerimiz
  1. SMS'deki türkçe karakter çilesi..

    SMS'deki türkçe karakter çilesi..

    Telekomünikasyon Kurumu İkinci Başkanı Galip Zerey, kısa mesajlarda Türkçe karakter sorununun Meksika'da yapılan 3GPP toplantısında ele alınacağını belirterek, ''Çözüm önerimiz kabul edilirse kısa mesajlarda Türkçe karakterler rahatlıkla kullanılabilecek ve 160 harften oluşan kısa mesajda Türkçe harf kullanılsa bile tek bir kısa mesaj ücretlendirilmesi olacak'' dedi. Telekomünikasyon Kurumu...
  2. karakteriniz

    karakteriniz

    ayin kacinda dogdunuz? bu sayi sizin karakter numaranizi belirler, mesela ayin 5 inde dogduysaniz siz 5 insanisiniz. ayin 11 inde dogduysaniz (1+1) 2 insanisiniz .... buna göre sizin özellikleriniz belirlenebiliyor.... iste numaralara göre karakteriniz: Sayi 1: özü: yaratici elemti: hava - lider - ucucu - parlak - neseli...
  3. 2008 kpss türkçe soru ve cevapları

    2008 kpss türkçe soru ve cevapları

    2008 kpss türkçe soruları ve cevapları KPSS'YE GİRECEK ARKADASLAR ESKİ SORULARI ÇÖZMENİZDE FAYDA VAR DİYORUM ÇÜNKÜ GENELDE BENZER SORULAR ÇIKIYOR GİRECEK ARKADSLARIMA BASARILAR DİLİYORUM BUYRUN TÜRKE SORULARI GENEL YETENEK TESTİ KPSS-ORTAÖĞR. / 2008 1 1. Çok küçük, çelimsiz bir örümcekti bu. Mercimek tanesi büyüklüğündeki bedeni yaylanıyor, ama tepeye tırmanma çabası her seferinde ----...
  4. 2007 kpss türkçe soru ve cevapları

    2007 kpss türkçe soru ve cevapları

    A GENEL YETENEK TESTİ KPSS-GYGK-CS/2007 Diğer sayfaya geçiniz. 1 1. Her yazıyı, her kitabı sözcük sözcük okumak ge- I rekli mi? Yazıdan yazıya, kitaptan kitaba değişir bu. Onlar arasında öyleleri vardır ki okuyayım diye kendimizi sıkmak gereksizdir. Ama öyle yazılar, ki- II taplar da vardır ki sözcükleri tada tada okuruz. Bu tür III yazılarda bizi kendine çeken nedir? Yazarın kişiliği,...
  5. Xenforo kullanıcı avatarı yüklenmiyor ?

    Xenforo kullanıcı avatarı yüklenmiyor ?

    Xenforo avatar yükleme sorunu avatar yüklenmiyor ? Kullanımının yanı sıra getirdiği yeni yeniliklerle artık forum siteleri mybb ve benzeri forum scriptlerinden inanılmaz derecede dönüş var xenforo scriptine. Özellikle işlemler baya bi sancılı oluyor bunu sizlere belirteyim arkadaşlarım. Sizler herşeyi tamamladığınız halde avatar yüklemeye çalışıyorsunuz ve avatarı yükleyip boş resim...

Sayfayı Paylaş