/**
 * Translate strings to the page language or a given language.
 *
 * Human-readable text that will be displayed somewhere within a page should
 * be run through the t() function.
 *
 * Examples:
 * @code
 * if (!$info || !$info['extension']) {
 * form_set_error('picture_upload', t('The uploaded file was not an image.'));
 * }
 *
 * $form['submit'] = array(
 * '#type' => 'submit',
 * '#value' => t('Log in'),
 * );
 * @endcode
 *
 * Any text within t() can be extracted by translators and changed into
 * the equivalent text in their native language.
 *
 * Special variables called "placeholders" are used to signal dynamic
 * information in a string which should not be translated. Placeholders
 * can also be used for text that may change from time to time (such as
 * link paths) to be changed without requiring updates to translations.
 *
 * For example:
 * @code
 * $output = t('There are currently %members and %visitors online.', array(
 * '%members' => format_plural($total_users, '1 user', '@count users'),
 * '%visitors' => format_plural($guests->count, '1 guest', '@count guests')));
 * @endcode
 *
 * There are three styles of placeholders:
 * - !variable, which indicates that the text should be inserted as-is. This is
 * useful for inserting variables into things like e-mail.
 * @code
 * $message[] = t("If you don't want to receive such e-mails, you can change your settings at !url.", array('!url' => url("user/$account->uid", array('absolute' => TRUE))));
 * @endcode
 *
 * - @variable, which indicates that the text should be run through
 * check_plain, to escape HTML characters. Use this for any output that's
 * displayed within a Drupal page.
 * @code
 * drupal_set_title($title = t("@name's blog", array('@name' => $account->name)));
 * @endcode
 *
 * - %variable, which indicates that the string should be HTML escaped and
 * highlighted with theme_placeholder() which shows up by default as
 * <em>emphasized</em>.
 * @code
 * $message = t('%name-from sent %name-to an e-mail.', array('%name-from' => $user->name, '%name-to' => $account->name));
 * @endcode
 *
 * When using t(), try to put entire sentences and strings in one t() call.
 * This makes it easier for translators, as it provides context as to what
 * each word refers to. HTML markup within translation strings is allowed, but
 * should be avoided if possible. The exception are embedded links; link
 * titles add a context for translators, so should be kept in the main string.
 *
 * Here is an example of incorrect usage of t():
 * @code
 * $output .= t('<p>Go to the @contact-page.</p>', array('@contact-page' => l(t('contact page'), 'contact')));
 * @endcode
 *
 * Here is an example of t() used correctly:
 * @code
 * $output .= '<p>'. t('Go to the <a href="@contact-page">contact page</a>.', array('@contact-page' => url('contact'))) .'</p>';
 * @endcode
 *
 * Avoid escaping quotation marks wherever possible.
 *
 * Incorrect:
 * @code
 * $output .= t('Don\'t click me.');
 * @endcode
 *
 * Correct:
 * @code
 * $output .= t("Don't click me.");
 * @endcode
 *
 * Because t() is designed for handling code-based strings, in almost all
 * cases, the actual string and not a variable must be passed through t().
 *
 * Extraction of translations is done based on the strings contained in t()
 * calls. If a variable is passed through t(), the content of the variable
 * cannot be extracted from the file for translation.
 *
 * Incorrect:
 * @code
 * $message = 'An error occurred.';
 * drupal_set_message(t($message), 'error');
 * $output .= t($message);
 * @endcode
 *
 * Correct:
 * @code
 * $message = t('An error occurred.');
 * drupal_set_message($message, 'error');
 * $output .= $message;
 * @endcode
 *
 * The only case in which variables can be passed safely through t() is when
 * code-based versions of the same strings will be passed through t() (or
 * otherwise extracted) elsewhere.
 *
 * In some cases, modules may include strings in code that can't use t()
 * calls. For example, a module may use an external PHP application that
 * produces strings that are loaded into variables in Drupal for output.
 * In these cases, module authors may include a dummy file that passes the
 * relevant strings through t(). This approach will allow the strings to be
 * extracted.
 *
 * Sample external (non-Drupal) code:
 * @code
 * class Time {
 * public $yesterday = 'Yesterday';
 * public $today = 'Today';
 * public $tomorrow = 'Tomorrow';
 * }
 * @endcode
 *
 * Sample dummy file.
 * @code
 * // Dummy function included in example.potx.inc.
 * function example_potx() {
 * $strings = array(
 * t('Yesterday'),
 * t('Today'),
 * t('Tomorrow'),
 * );
 * // No return value needed, since this is a dummy function.
 * }
 * @endcode
 *
 * Having passed strings through t() in a dummy function, it is then
 * okay to pass variables through t().
 *
 * Correct (if a dummy file was used):
 * @code
 * $time = new Time();
 * $output .= t($time->today);
 * @endcode
 *
 * However tempting it is, custom data from user input or other non-code
 * sources should not be passed through t(). Doing so leads to the following
 * problems and errors:
 * - The t() system doesn't support updates to existing strings. When user
 * data is updated, the next time it's passed through t() a new record is
 * created instead of an update. The database bloats over time and any
 * existing translations are orphaned with each update.
 * - The t() system assumes any data it receives is in English. User data may
 * be in another language, producing translation errors.
 * - The "Built-in interface" text group in the locale system is used to
 * produce translations for storage in .po files. When non-code strings are
 * passed through t(), they are added to this text group, which is rendered
 * inaccurate since it is a mix of actual interface strings and various user
 * input strings of uncertain origin.
 *
 * Incorrect:
 * @code
 * $item = item_load();
 * $output .= check_plain(t($item['title']));
 * @endcode
 *
 * Instead, translation of these data can be done through the locale system,
 * either directly or through helper functions provided by contributed
 * modules.
 * @see hook_locale()
 *
 * During installation, st() is used in place of t(). Code that may be called
 * during installation or during normal operation should use the get_t()
 * helper function.
 * @see st()
 * @see get_t()
 *
 * @param $string
 * A string containing the English string to translate.
 * @param $args
 * An associative array of replacements to make after translation. Incidences
 * of any key in this array are replaced with the corresponding value. Based
 * on the first character of the key, the value is escaped and/or themed:
 * - !variable: inserted as is
 * - @variable: escape plain text to HTML (check_plain)
 * - %variable: escape text and theme as a placeholder for user-submitted
 * content (check_plain + theme_placeholder)
 * @param $langcode
 * Optional language code to translate to a language other than what is used
 * to display the page.
 * @return
 * The translated string.
 */
function _t($string, $args = array(), $langcode = NULL, $reset = FALSE)
{
    global $language, $cfg;
    static $locale_t = NULL;
    //@TODO se quiser fazer texto custom
    if ($reset) {
        // Reset in-memory cache.
        $locale_t = NULL;
    }
    if (!isset($string)) {
        // Return all cached strings if no string was specified
        return $locale_t;
    }
    $langcode = isset($langcode) ? $langcode : $language['language']->language;
    //@TODO verificr se esta consumindo muita memoria qualquer coisa cachear
    if (isset($language['translate'])) {
        $po = new PO();
        $po->merge_with($language['translate']);
        $string = $po->translate($string);
    }
    if (empty($args)) {
        return $string;
    } else {
        // Transform arguments before inserting them.
        foreach ($args as $key => $value) {
            switch ($key[0]) {
                case '@':
                    // Escaped only.
                    $args[$key] = check_plain($value);
                    break;
                case '%':
                default:
                    //@todo Escaped and placeholder.
                    //$args[$key] = theme('placeholder', $value);
                    break;
                case '!':
                    // Pass-through.
            }
        }
        return strtr($string, $args);
    }
}
 /**
  * Configura a linguagem padr�o
  */
 private function GetLanguage()
 {
     $mysql = new MysqlConsulta($this->cfg);
     $this->language['language_default'] = $mysql->getLanguagefromCOUNTRY($this->cfg['ID_COUNTRY']);
     //--> en,pt-br,ja,it
     $this->language['language'] = $mysql->ListLanguages($this->language['language_default']);
     if (isset($this->perfil->user_language)) {
         $this->language['language_default'] = $this->perfil->user_language;
         $this->language['language'] = $mysql->ListLanguages($this->perfil->user_language);
     }
     if (isset($_GET['q'])) {
         $query = getLanguageURL($_GET['q']);
         if ($query[1]) {
             $this->language['language_default'] = $query[1];
             $this->language['language'] = $mysql->ListLanguages($query[1]);
         }
         $_GET['q'] = $query[0];
     }
     if ($this->language['language']->language != language_default()->language) {
         $this->language['translate'] = $mysql->getTranslate($this->language['language']->language);
         if (!$this->language['translate']) {
             $po = loadPO($this->language['language']->language);
             if ($po == false) {
                 //@todo mensagem de errooooo
                 $message = _t("File not found a standard language for this request.");
                 setMessage($message, 'error');
             }
             insertTranslation($po);
         } else {
             $po = new PO();
             $po->set_headers($this->language['translate']->headers);
             $po->merge_with($this->language['translate']);
             //@todo = verificar esta requisições de texto, se a função de tradução não irá cumprir o mesmo papel
         }
         $this->language['translate'] = $po;
     }
 }