Crowdin In-Context works with the help of a one-line Javascript snippet and pseudo-language package. It creates a pseudo-language package based on the localization files uploaded to your project, which later will be integrated into your application as an additional localization language.
Integrated pseudo-language contains special identifiers instead of the original texts. Thus when switching your app to that language, all labels are converted to special identifiers. Javascript searches for those identifiers and replaces them with editable labels. So, the In-context page of your web app will look the same as your application, with the only difference that translatable strings will be editable.
Translations are made directly in the app, with no need to open the Editor. A simplified version of Crowdin Editor will be displayed, with all the functionality (TM, machine translation, approve/vote option, comments, terms) provided. Thus, it’s easier to make and review translations since translators can preview them in a real context.
There are two common approaches to integrate Crowdin In-Context with your application:
Staging or translation environment
If you are not planning to invite your end-users to help with translations or not considering using a “translation mode” in your production application, integrating Crowdin In-Context to your staging or dedicated translation app environment would be a good solution.
Production environment
Crowdin In-Context doesn’t require any code changes in your application so that you can use it even on production. You decide how to turn it on and which segment of users will use it. The most common use cases are the following:
Follow the integration setup guide in your Crowdin project to set up In-context. The guide can be found in the left-hand panel in your project, under Tools > In-Context.
After the integration is successfully set up and you have refreshed your application, you should see the invitation dialog and Crowdin login box.
When integrating In-Context for your website, you can add an optional script that can collect and add URLs to the context section of each string used on the website.
As a result, translators can click the URL for a particular string and be redirected to the website page where this string is used and get additional context for accurate translation.
To add string URLs to context, follow these steps:
Copy the following JavaScript snippet and paste it right after the primary In-Context JavaScript snippet (which could be found in your Crowdin project’s Tools tab) at the <head>
section on every page with localizable text.
<script type="text/javascript">
var _jipt = [];
_jipt.push(['project', 'your_project_identifier']);
_jipt.push(['preload_texts', false]);
_jipt.push(['edit_strings_context', function(context) {
var separator = "\n";
var lineStart = "* ";
var contextParts = context.split(separator);
var linkCount = 0;
for(var i in contextParts) {
var line = contextParts[i];
if(lineStart + window.location.href === line) {
return context;
}
if(line.indexOf(lineStart) === 0) {
linkCount++;
}
if(line === 'And more...') {
return context;
}
}
if(linkCount < 5) {
return context + separator + lineStart + window.location.href;
}
return context + separator + 'And more...';
}]);
</script>
Once finished, each website’s page you’d like to translate via In-Context should contain two JavaScript snippets:
After adding JavaScript snippets, you should open each website page where In-Context is integrated. That will allow the additional JavaScript snippet to collect and add string URLs to your Crowdin project.
When you add a new page to your website, upload the related source files to your Crowdin project. Afterward, repeat the steps above to collect and add URLs for strings from the new page.
If some website page’s URL changes, open it in In-Context to refresh the string URLs collected initially.
You can add these parameters to the _jipt
array in the configuration snippet.
_jipt.push(['preload_texts', true]);
Speeds up dynamic content displaying within the In-Context tool by preloading all source strings. Automatically disabled for large projects (5000+ strings). Acceptable values: true, false.
_jipt.push(['touch_optimized', true]);
This option is enabled on touchscreens by default and makes the translation button next to each translatable string permanently visible instead of showing on hover. Acceptable values: true, false.
_jipt.push(['before_commit', function(source, translation, context, language_code) {
return status_obj;
}]);
Function to validate the suggestion before committing.
Parameters | |
source | Source text |
translation | Translation text |
context | Source string context |
language_code | Target language code (language codes) |
Return Values | |
status_obj | Object. The status_obj.status may be "ok", "error" or "corrected". In case of error, status_obj.message contains error description. When status is "corrected", status_obj.correction contains the corrected translation |
_jipt.push(['before_dom_insert', function(text, node, attribute) {
return 'text';
}]);
Function to transform the string before it gets inserted into the DOM.
Parameters | |
text | String for insertion |
node optional | DOM element in which the text must be inserted. It may be omitted if the text doesn't have a target element (text inside the browser's pop-ups) |
attribute optional | The attribute of DOM element, if the text is part of an attribute |
Return Values | |
text | String for insertion |
false | If the function returns false, DOM will not be updated |
_jipt.push(['escape', function() {
window.location.href = "http://app_domain.com";
}]);
If defined, users can close the In-Context overlay if they don’t want to translate. Implement this feature on your side. Depending on the In-Context integration approach, it must change the app’s language or redirect from the translation environment to the production app.
This feature allows you to take a screenshot of the opened website page, upload it to the Crowdin project and automatically tag all strings used on the page.
Read more about Screenshots.