immibis
/
colobot-data
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

First part of rewriting scripts for level translations 

* support translating the new chaptertitle.txt files
 * handle the new directory structure
 * move writing PO4A config to CMake
 * use only one bash script to generate translated files
 * additional step of cleaning *.po and *.pot files
 * change some PO4A flags for better console output and sorting of
   messages in *.po files
dev-hd-graphics
Piotr Dziwinski 2014-09-20 13:37:26 +02:00
parent 41592a8b5a
commit 946a083606
14 changed files with 260 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -18,5 +18,6 @@ install(DIRECTORY sounds DESTINATION ${COLOBOT_INSTALL_DATA_DIR})
install(DIRECTORY textures DESTINATION ${COLOBOT_INSTALL_DATA_DIR})
install(DIRECTORY DESTINATION ${COLOBOT_INSTALL_DATA_DIR}/mods) # Empty directory
set(DATA_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
add_subdirectory(help)
add_subdirectory(levels)

32
help/CMakeLists.txt
View File

@ -1,33 +1,3 @@
cmake_minimum_required(VERSION 2.8)
set(LEVELS_I18N_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../levels-i18n/)
# Handle all help categories' translations
foreach(LEVEL_CODENAME cbot;object)
set(SCENEFILE)
set(SCENEDEST)
set(PODIR "${LEVEL_CODENAME}/po/")
set(HELPDIR "${LEVEL_CODENAME}/")
set(HELPDEST "${LEVEL_CODENAME}")
message(STATUS "Managing translations for '${LEVEL_CODENAME}' help category")
include(${LEVELS_I18N_PATH}/CMakeLists.txt)
endforeach()
set(LEVEL_CODENAME generic)
set(SCENEFILE)
set(SCENEDEST)
set(PODIR "${LEVEL_CODENAME}/po/")
set(HELPDIR "${LEVEL_CODENAME}/")
set(HELPDEST "")
message(STATUS "Managing translations for '${LEVEL_CODENAME}' help category")
include(${LEVELS_I18N_PATH}/CMakeLists.txt)
set(LEVEL_CODENAME bots)
set(SCENEFILE)
set(SCENEDEST)
set(PODIR "${LEVEL_CODENAME}/po/")
set(HELPDIR "${LEVEL_CODENAME}/")
set(HELPDEST "object/")
message(STATUS "Managing translations for '${LEVEL_CODENAME}' help category")
include(${LEVELS_I18N_PATH}/CMakeLists.txt)
# TODO handle help files...

92
i18n-tools/LevelsI18N.cmake Normal file
View File

@ -0,0 +1,92 @@
##
# Meta-infrastructure to allow po-based translation of Colobot help files and scene-description (level) files.
##
find_program(PO4A po4a)
if(NOT PO4A)
message(WARNING "PO4A not found, level files will NOT be translated!")
endif()
set(LEVEL_INSTALL_DATA_DIR ${COLOBOT_INSTALL_DATA_DIR}/levels)
set(HELP_INSTALL_DATA_DIR ${COLOBOT_INSTALL_DATA_DIR}/help)
set(LEVELS_I18N_WORK_DIR ${CMAKE_CURRENT_BINARY_DIR}/levels-po)
##
# Generate translated chaptertitle files using po4a
##
function(generate_chaptertitles_i18n result_translated_chaptertitle_files source_chaptertitle_files po_dir)
get_filename_component(abs_po_dir ${po_dir} ABSOLUTE)
# generated config file for po4a
set(po4a_cfg_file ${LEVELS_I18N_WORK_DIR}/${po_dir}/chaptertitles_po4a.cfg)
# generated dummy file for translation of "E", "D", "F", "P", etc. language letters
set(langchar_file ${LEVELS_I18N_WORK_DIR}/${po_dir}/chaptertitles_langchar.txt)
file(WRITE ${langchar_file} "E")
# get translations from po directory
file(WRITE ${po4a_cfg_file} "[po_directory] ${abs_po_dir}\n")
# add content of dummy language file to translation
file(APPEND ${po4a_cfg_file} "[type:text] ${langchar_file}")
set(abs_source_chaptertitle_files "")
set(translated_chaptertitle_files "")
file(GLOB po_files ${po_dir}/*.po)
foreach(source_chaptertitle_file ${source_chaptertitle_files})
get_filename_component(abs_source_chaptertitle_file ${source_chaptertitle_file} ABSOLUTE)
set(output_chaptertitle_file ${LEVELS_I18N_WORK_DIR}/${source_chaptertitle_file})
# translation rule for chaptertitle file
file(APPEND ${po4a_cfg_file} "\n[type:colobotlevel] ${abs_source_chaptertitle_file}")
foreach(po_file ${po_files})
get_filename_component(po_file_name ${po_file} NAME)
# get language code e.g. "de"
string(REPLACE ".po" "" language_code ${po_file_name})
# generated file for single language
set(generated_language_file ${output_chaptertitle_file}.${language_code})
file(APPEND ${po4a_cfg_file} " \\\n ${language_code}:${generated_language_file}")
endforeach()
list(APPEND abs_source_chaptertitle_files ${abs_source_chaptertitle_file})
list(APPEND translated_chaptertitle_files ${output_chaptertitle_file})
endforeach()
# dummy files to signal that scripts have finished running
set(translation_signalfile ${LEVELS_I18N_WORK_DIR}/${po_dir}/translations)
set(po_clean_signalfile ${LEVELS_I18N_WORK_DIR}/${po_dir}/po_clean)
# script to run po4a and consolidate the translations
string(REPLACE ";" ":" escaped_abs_source_chaptertitle_files "${abs_source_chaptertitle_files}")
string(REPLACE ";" ":" escaped_translated_chaptertitle_files "${translated_chaptertitle_files}")
add_custom_command(OUTPUT ${translation_signalfile}
COMMAND ${DATA_SOURCE_DIR}/i18n-tools/scripts/create_translations.sh ${escaped_abs_source_chaptertitle_files} ${escaped_translated_chaptertitle_files} ${po4a_cfg_file} ${translation_signalfile}
DEPENDS ${po_files})
file(GLOB pot_file ${po_dir}/*.pot)
set(po_files ${po_files} ${pot_file})
# script to do some cleanups in updated *.po and *.pot files
string(REPLACE ";" ":" escaped_po_files "${po_files}")
add_custom_command(OUTPUT ${po_clean_signalfile}
COMMAND ${DATA_SOURCE_DIR}/i18n-tools/scripts/clean_po_files.sh ${escaped_po_files} ${translation_signalfile} ${po_clean_signalfile}
DEPENDS ${translation_signalfile}
)
# generate some unique string for target name
string(REGEX REPLACE "[/\\]" "_" target_suffix ${po_dir})
add_custom_target(level_i18n-${target_suffix} ALL DEPENDS ${translation_signalfile} ${po_clean_signalfile})
set(${result_translated_chaptertitle_files} ${translated_chaptertitle_files} PARENT_SCOPE)
endfunction()
##
# Generate translated level file using po4a
##
function(generate_scene_i18n translated_scene_file_path source_level_file)
# TODO finish level translation...
endfunction()

28
i18n-tools/scripts/clean_po_files.sh Executable file
View File

@ -0,0 +1,28 @@
#!/bin/bash
# Stop on errors
set -e
if [ $# -ne 3 ]; then
echo "Invalid arguments!" >&2
echo "Usage: $0 po_file1[:po_file2;...] translation_signalfile po_clean_signalfile" >&2
exit 1
fi
PO_FILES="$1"
TRANSLATION_SIGNALFILE="$2"
PO_CLEAN_SIGNALFILE="$3"
IFS=':' read -a po_files_array <<< "$PO_FILES"
for po_file in "${po_files_array[@]}"; do
# strip unnecessary part of file names
sed -i -E 's|^#: .*(levels/.*)$|#: \1|' "$po_file"
# remove the creation date
sed -i -E 's|^("POT-Creation-Date:).*$|\1 DATE\\n"|' "$po_file"
done
# update the dummy signal files to indicate success
# we also have to touch translation signalfile because it's supposed to be modified later than po files
touch "$TRANSLATION_SIGNALFILE"
touch "$PO_CLEAN_SIGNALFILE"

54
i18n-tools/scripts/create_translations.sh Executable file
View File

@ -0,0 +1,54 @@
#!/bin/bash
# Stop on errors
set -e
if [ $# -ne 4 ]; then
echo "Invalid arguments!" >&2
echo "Usage: $0 source_file1[:source_file2:...] output_file1[:output_file2:...] po4a_config_file translation_signalfile" >&2
exit 1
fi
SOURCE_FILES="$1"
OUTPUT_FILES="$2"
PO4A_FILE="$3"
TRANSLATION_SIGNALFILE="$4"
# get the directory where the script is in
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
# generate translated files using po4a
if [ -n "$VERBOSE" ]; then
verbosity="-v"
else
verbosity="-q"
fi
PERL5LIB="${SCRIPT_DIR}/perllib${PERL5LIB+:}$PERL5LIB" po4a -k0 $verbosity -f "$PO4A_FILE" --msgmerge-opt -F
IFS=':' read -a source_files_array <<< "$SOURCE_FILES"
IFS=':' read -a output_files_array <<< "$OUTPUT_FILES"
for index in "${!source_files_array[@]}"; do
source_file="${source_files_array[index]}"
output_file="${output_files_array[index]}"
# generate output file
echo -n "" > "$output_file"
# first, write original English headers
sed -n '/^Title/p;/^Resume/p;/^ScriptName/p' "$source_file" >> "$output_file"
# now, copy translated headers from translated files
# (translated files are named output file + suffix with language code)
for translated_file in $output_file.*; do
sed -n '/^Title/p;/^Resume/p;/^ScriptName/p' "$translated_file" >> "$output_file"
done
echo "// End of level headers translations" >> "$output_file"
echo "" >> "$output_file"
# copy the rest of source file, excluding headers
sed -e '/^Title/d;/^Resume/d;/^ScriptName/d' "$source_file" >> "$output_file"
done
# update the dummy signal file to indicate success
touch "$TRANSLATION_SIGNALFILE"

0
levels-i18n/scripts/perllib/Locale/Po4a/Colobothelp.pm → i18n-tools/scripts/perllib/Locale/Po4a/Colobothelp.pm
View File

41
levels-i18n/scripts/perllib/Locale/Po4a/Colobotlevel.pm → i18n-tools/scripts/perllib/Locale/Po4a/Colobotlevel.pm
View File

@ -26,11 +26,11 @@ sub initialize {}
sub parse {
my $self=shift;
my ($line,$ref);
my $parE;
my ($line,$line_source);
my $language_char;
LINE:
($line,$ref)=$self->shiftline();
($line,$line_source)=$self->shiftline();
while (defined($line)) {
chomp($line);
@ -43,9 +43,9 @@ sub parse {
# One char just after the .
$line =~ m/\.(.)/;
my $E = $1;
if( not $parE ) {
if (not $language_char) {
# Take this one-char only once
$parE = $self->translate($E, '', 'One-char language identifier');
$language_char = $self->translate($E, '', 'One-char language identifier');
}
# The text between .E and first quote
@ -58,17 +58,27 @@ sub parse {
my $subtype_2 = $6;
my $quoted_2 = $7;
my $spacing_3 = $8;
$ref =~ m#^(.*)/(.*)\.txt.*$#;
my $code;
if( $2 eq 'scene' ) {
$code = $1;
} else {
$code = $2;
# levels/<category>/chapterXXX/chaptertitle.txt
if ($line_source =~ m#^.*/levels/([^/]*)/chapter([0-9]{3})/chaptertitle\.txt.*$#) {
$code = $1.".".$2; # e.g. challenges.001
}
my $par_1 = $self->translate($code.":".$quoted_1, $ref, $type."-".$subtype_1);
# levels/<category>/chapterXXX/levelYYY/scene.txt
elsif ($line_source =~ m#^.*/levels/[^/]*/chapter([0-9]{3})/level([0-9]{3})/scene\.txt.*$#) {
$code = $1.".".$2.".".$3; # e.g. challenges.001.002
}
# fallback case
else {
$line_source =~ m#^.*/([^/]*)$#;
$code = $1;
}
my $par_1 = $self->translate($code.":".$quoted_1, $line_source, $type."-".$subtype_1);
$par_1 =~ s/^\D*\d*://;
if ($secondpart) {
my $par_2 = $self->translate($code.":".$quoted_2, $ref, $type."-".$subtype_2);
my $par_2 = $self->translate($code.":".$quoted_2, $line_source, $type."-".$subtype_2);
$par_2 =~ s/^\D*\d*://;
# This is awkward, but works
@ -78,14 +88,13 @@ sub parse {
$spacing_2 =~ s/\n/\\n/g;
# Now push the result
$self->pushline($type.'.'.$parE.$spacing_1.$subtype_1.'="'.$par_1.'"'.$spacing_2."\n");
$self->pushline($type.'.'.$language_char.$spacing_1.$subtype_1.'="'.$par_1.'"'.$spacing_2."\n");
}
else
{
else {
$self->pushline("$line\n");
}
# Reinit the loop
($line,$ref)=$self->shiftline();
($line,$line_source)=$self->shiftline();
}
}

120
levels-i18n/CMakeLists.txt
View File

@ -1,120 +0,0 @@
cmake_minimum_required(VERSION 2.8)
# Meta-infrastructure to allow po-based translation of Colobot help files and scene-description (level) files.
# set(LEVELS_I18N_PATH ${CMAKE_CURRENT_SOURCE_DIR})
# set(LEVEL_CODENAME "scene100")
# set(SCENEFILE "scene100/scene.txt")
# set(SCENEDEST "scene101.txt") # If unset , use the same name as SCENEFILE
# set(PODIR "scene100/po/")
# set(HELPDIR "scene100/help/")
# set(HELPDEST "")
project(colobot-level-${LEVEL_CODENAME} NONE)
if(NOT DEFINED COLOBOT_INSTALL_DATA_DIR)
set(COLOBOT_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share/games/colobot CACHE PATH "Colobot shared data directory")
endif()
set(LEVEL_INSTALL_DATA_DIR ${COLOBOT_INSTALL_DATA_DIR}/levels/)
set(HELP_INSTALL_DATA_DIR ${COLOBOT_INSTALL_DATA_DIR}/help/)
# Translate translatable material
find_program(PO4A po4a)
if(NOT PO4A)
message(WARNING "PO4A not found, level files will NOT be translated!")
endif()
### STEP 3 # Inject translations in levels
set(_levels_i18n_target "levels_i18n")
file(GLOB levelfiles "${CMAKE_CURRENT_SOURCE_DIR}/${SCENEFILE}")
foreach(levelfile ${levelfiles})
if(DEFINED SCENEDEST)
get_filename_component(_scenedest ${SCENEDEST} NAME)
else()
get_filename_component(_scenedest ${levelfile} NAME)
endif()
get_filename_component(_levelfile ${levelfile} NAME_WE)
if(PO4A AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${PODIR}")
file(GLOB pofiles "${CMAKE_CURRENT_SOURCE_DIR}/${PODIR}/*.po")
add_custom_command(OUTPUT ${_levels_i18n_target}/${_scenedest}
COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${_levels_i18n_target}
COMMAND ${LEVELS_I18N_PATH}/scripts/03_inject_translations.sh ${levelfile} ${CMAKE_CURRENT_BINARY_DIR}/${LEVEL_CODENAME}/${_levelfile} ${PODIR} ${CMAKE_CURRENT_BINARY_DIR}/${_levels_i18n_target}/${_scenedest}
DEPENDS po4a-${LEVEL_CODENAME} ${pofiles}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "${LEVEL_CODENAME}: Inject translation in ${_scenedest}"
)
else()
add_custom_command(OUTPUT ${_levels_i18n_target}/${_scenedest}
COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${_levels_i18n_target}
COMMAND cp ${levelfile} ${CMAKE_CURRENT_BINARY_DIR}/${_levels_i18n_target}/${_scenedest}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
COMMENT "${LEVEL_CODENAME}: Move untranslatable ${_scenedest}"
)
endif()
add_custom_target(level_i18n-${LEVEL_CODENAME}_${_levelfile} ALL DEPENDS ${_levels_i18n_target}/${_scenedest})
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_levels_i18n_target}/${_scenedest}
DESTINATION ${LEVEL_INSTALL_DATA_DIR})
endforeach()
file(GLOB helpfiles "${CMAKE_CURRENT_SOURCE_DIR}/${HELPDIR}/E/*.txt")
list(SORT helpfiles)
if(PO4A AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${PODIR}")
foreach(helpfile ${helpfiles})
get_filename_component(_helpfile_we ${helpfile} NAME_WE)
get_filename_component(_helpfile ${helpfile} NAME)
### STEP 4 # Put translated help files in the correct place
set(_help_i18n_target "help_i18n_${LEVEL_CODENAME}_${_helpfile_we}")
add_custom_command(OUTPUT moved-all-${LEVEL_CODENAME}-${_helpfile}
COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${_help_i18n_target}
COMMAND ${LEVELS_I18N_PATH}/scripts/04_move_helpfiles_to_paths.sh ${LEVEL_CODENAME} ${LEVEL_CODENAME}-help/${_helpfile} ${_help_i18n_target} '${HELPDIR}' '${HELPDEST}' ${CMAKE_CURRENT_SOURCE_DIR} > moved-all-${LEVEL_CODENAME}-${_helpfile}
DEPENDS po4a-${LEVEL_CODENAME}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "${LEVEL_CODENAME}: Move ${_helpfile} translations around"
)
add_custom_target(help_i18n-${LEVEL_CODENAME}_${_helpfile_we} ALL DEPENDS moved-all-${LEVEL_CODENAME}-${_helpfile})
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_help_i18n_target}/
DESTINATION ${HELP_INSTALL_DATA_DIR})
endforeach()
elseif(DEFINED HELPDIR AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${HELPDIR}")
set(_help_i18n_target "help_i18n_${LEVEL_CODENAME}")
add_custom_command(OUTPUT moved-all-${LEVEL_CODENAME}
COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${_help_i18n_target}
COMMAND ${LEVELS_I18N_PATH}/scripts/05_move_untranslated_helpfiles_to_paths.sh '${_help_i18n_target}' '${HELPDEST}' '${CMAKE_CURRENT_SOURCE_DIR}/${HELPDIR}' > moved-all-${LEVEL_CODENAME}-${_helpfile}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "${LEVEL_CODENAME}: Move untranslatable help files"
)
add_custom_target(help_i18n-${LEVEL_CODENAME} ALL DEPENDS moved-all-${LEVEL_CODENAME})
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${_help_i18n_target}/
DESTINATION ${HELP_INSTALL_DATA_DIR})
endif()
#### STEP 1 # Create po4a.cfg file out of the list of files
add_custom_command(OUTPUT po4a-${LEVEL_CODENAME}.cfg
COMMAND ${LEVELS_I18N_PATH}/scripts/01_create_po4a_file.sh ${CMAKE_CURRENT_SOURCE_DIR} ${PODIR} ${LEVEL_CODENAME} '${SCENEFILE}' '${HELPDIR}/E' > ${CMAKE_CURRENT_BINARY_DIR}/po4a-${LEVEL_CODENAME}.cfg
COMMENT "${LEVEL_CODENAME}: Create po4a configuration file"
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
if(PO4A AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${PODIR})
#### STEP 2 # Run po4a
file(GLOB pofiles "${CMAKE_CURRENT_SOURCE_DIR}/${PODIR}/*.po")
add_custom_command(OUTPUT po4a-ran-${LEVEL_CODENAME}
COMMAND ${LEVELS_I18N_PATH}/scripts/02_run_po4a.sh ${LEVELS_I18N_PATH} ${CMAKE_CURRENT_BINARY_DIR}/po4a-${LEVEL_CODENAME}.cfg
COMMAND touch po4a-ran-${LEVEL_CODENAME}
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/po4a-${LEVEL_CODENAME}.cfg ${pofiles}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "${LEVEL_CODENAME}: Run po4a to generate the translated files out of the .po files")
add_custom_target(po4a-${LEVEL_CODENAME} DEPENDS po4a-ran-${LEVEL_CODENAME})
else()
message(STATUS "${LEVEL_CODENAME}: No translation needed or possible")
file(GLOB levelfiles "${CMAKE_CURRENT_SOURCE_DIR}/levels/*.txt")
install(FILES ${levelfiles} DESTINATION ${LEVEL_INSTALL_DATA_DIR}/)
endif()

54
levels-i18n/scripts/01_create_po4a_file.sh
View File

@ -1,54 +0,0 @@
#!/bin/sh
set -e
# MUST be run from ${CMAKE_CURRENT_BINARY_DIR}
srcdir=$1 # absolute
PODIR=$2 # relative
LEVEL_CODENAME=$3 # relative
SCENEFILE=$4 # relative
HELPDIR=$5 # relative
if [ ! -d $LEVEL_CODENAME-po -o -h $LEVEL_CODENAME-po ]; then
rm -f $LEVEL_CODENAME-po
ln -sf $srcdir/$PODIR $LEVEL_CODENAME-po
fi
echo "[po_directory] $LEVEL_CODENAME-po"
# Create a pseudo file for the translation of the language code
echo "[type:text] ${LEVEL_CODENAME}.languagecode \$lang:${LEVEL_CODENAME}.\$lang.languagecode"
echo "E" > ${LEVEL_CODENAME}.languagecode
# Create symlink for relative paths in po4a
mkdir -p $LEVEL_CODENAME
if [ -n "$SCENEFILE" ]; then
# Levels are precompiled, they are already in the current dir
for scene in $(cd $srcdir/; ls $SCENEFILE); do
scene_=$(basename $scene .txt)
$(cd $LEVEL_CODENAME;
if [ ! -f $scene_.txt -o -h $scene_.txt ]; then
rm -f $scene_.txt;
ln -sf $srcdir/$scene $scene_.txt;
fi
)
echo "[type:colobotlevel] $LEVEL_CODENAME/$scene_.txt \$lang:$LEVEL_CODENAME/$scene_.\$lang.txt"
done
fi
# Create symlink for relative paths in po4a
mkdir -p $LEVEL_CODENAME-help
if [ -d $srcdir/$HELPDIR ]; then
for helpfile in $(cd $srcdir/$HELPDIR; ls *.txt); do
helpfile_=$(basename $helpfile .txt)
$(cd $LEVEL_CODENAME-help;
if [ ! -f $helpfile_.txt -o -h $helpfile_.txt ]; then
rm -f $helpfile_.txt;
ln -sf $srcdir/$HELPDIR/$helpfile $helpfile_.txt;
fi
)
echo "[type:colobothelp] $LEVEL_CODENAME-help/$helpfile_.txt \$lang:$LEVEL_CODENAME-help/$helpfile_.\$lang.txt"
done
fi

10
levels-i18n/scripts/02_run_po4a.sh
View File

@ -1,10 +0,0 @@
#!/bin/sh
set -e
LEVELS_I18N_PATH=$1
PO4A_FILE=$2
export PERL5LIB=${LEVELS_I18N_PATH}/scripts/perllib${PERL5LIB+:}$PERL5LIB
po4a -k0 -v -f $PO4A_FILE

31
levels-i18n/scripts/03_inject_translations.sh
View File

@ -1,31 +0,0 @@
#!/bin/sh
set -e
levelfile=$1
translations_prefix=$2
PODIR=$3
targetfile=$4
rootfilename=$(basename $translations_prefix)
# Autodetect translated languages
script_path=$(dirname $0)
linguas=$(cd $PODIR/; ls *.po | sed -e 's/\.po$//g')
echo -n "" > $targetfile
# Make sure we take english (first, but it's not really important)
for lang in en $linguas; do
dotlang=".$lang"
if [ "$lang" = "en" ]; then
dotlang="";
fi
i18nfile=$translations_prefix$dotlang.txt
if [ -f $i18nfile ]; then
sed -n '/^Title/p;/^Resume/p;/^ScriptName/p' $i18nfile >> $targetfile
fi
done
echo "// End of level headers translations" >> $targetfile
echo "" >> $targetfile
sed -e '/^Title/d;/^Resume/d;/^ScriptName/d' $levelfile >> $targetfile

42
levels-i18n/scripts/04_move_helpfiles_to_paths.sh
View File

@ -1,42 +0,0 @@
#!/bin/sh
set -e
codename=$1
orig_file=$2
dest_dir=$3
HELPDIR=$4
HELPDEST=$5
CMAKE_CURRENT_SOURCE_DIR=$6
orig_l10n_file=$(basename $orig_file .txt)
orig_l10n_dir=$(dirname $orig_file)
# Get all language codes
for lcodef in $(ls ${codename}.*.languagecode); do
# Get the one-letter language code
LCODE=$(cat $lcodef)
lang=$(echo $lcodef | sed -e 's/.*\.\(.*\)\.languagecode/\1/')
# Foreach, rename the source files
mkdir -p $dest_dir/$LCODE/$HELPDEST
orig_trans=$CMAKE_CURRENT_SOURCE_DIR/$HELPDIR/$LCODE/$orig_l10n_file.txt
# Copy the translated file to the correct pathi
if [ -e $orig_l10n_dir/$orig_l10n_file.$lang.txt ]; then
cp -Lf $orig_l10n_dir/$orig_l10n_file.$lang.txt $dest_dir/$LCODE/$HELPDEST/$orig_l10n_file.txt
# Mark the source file that the translation is supposed to replace # Replace false by true to make it happen
if [ -e $orig_trans ] && false; then
sed -e '/Obsoleted translation/d;/This translated file/d' $orig_trans >$orig_trans.temp
echo "\\\\b; Obsoleted translation\nThis translated file has been replaced by it's PO-based counterpart and should be removed.\n" > $orig_trans
cat $orig_trans.temp >> $orig_trans
rm $orig_trans.temp
fi
elif [ -e $orig_trans ]; then
cp -Lf $orig_trans $dest_dir/$LCODE/$HELPDEST/$orig_l10n_file.txt
fi
done
mkdir -p $dest_dir/E/$HELPDEST
# Copy the english file to the correct path too
cp -Lf $orig_file $dest_dir/E/$HELPDEST/$orig_l10n_file.txt

14
levels-i18n/scripts/05_move_untranslated_helpfiles_to_paths.sh
View File

@ -1,14 +0,0 @@
#!/bin/sh
set -e
HELP_I18N_TARGET=$1
HELPDEST=$2
HELPDIR_FULL=$3
for langdir in $(ls ${HELPDIR_FULL}); do
if [ "$langdir" != "po" ]; then
mkdir -p ${HELP_I18N_TARGET}/$langdir/${HELPDEST}
cp ${HELPDIR_FULL}/$langdir/* ${HELP_I18N_TARGET}/$langdir/${HELPDEST}/
fi
done

81
levels/CMakeLists.txt
View File

@ -1,31 +1,62 @@
cmake_minimum_required(VERSION 2.8)
set(LEVELS_I18N_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../levels-i18n/)
include(../i18n-tools/LevelsI18N.cmake)
# Handle level headers' translations
file(GLOB levelheaders_po ${CMAKE_CURRENT_SOURCE_DIR}/*-po/)
foreach(levelheader_po ${levelheaders_po})
string(REPLACE "-po" "" levelheader ${levelheader_po})
get_filename_component(LEVEL_CODENAME ${levelheader} NAME)
set(SCENEFILE "${LEVEL_CODENAME}*.txt")
set(SCENEDEST)
set(PODIR "${LEVEL_CODENAME}-po/")
set(HELPDIR)
set(HELPDEST "")
message(STATUS "Manage translations for level headers '${LEVEL_CODENAME}*'")
include(${LEVELS_I18N_PATH}/CMakeLists.txt)
##
# Add level category directory with all chapters inside
##
function(add_level_category level_category_dir)
file(GLOB chaptertitle_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${level_category_dir}/chapter*/chaptertitle.txt)
if(PO4A AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${level_category_dir}/po/)
generate_chaptertitles_i18n(translated_chaptertitle_files "${chaptertitle_files}" ${level_category_dir}/po)
else()
set(translated_chaptertitle_files ${chaptertitle_files})
endif()
file(GLOB chapter_dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${level_category_dir}/chapter*)
list(LENGTH chapter_dirs chapter_dirs_count)
math(EXPR iterate_range "${chapter_dirs_count} - 1")
foreach(index RANGE ${iterate_range})
list(GET chapter_dirs ${index} chapter_dir)
list(GET translated_chaptertitle_files ${index} translated_chaptertitle_file)
install(FILES ${translated_chaptertitle_file} DESTINATION ${LEVEL_INSTALL_DATA_DIR}/${chapter_dir})
endforeach()
# Handle all levels' translations
file(GLOB levelcategories_paths ${CMAKE_CURRENT_SOURCE_DIR}/*/scene.txt)
foreach(levelcategory_path ${levelcategories_paths})
string(REPLACE "//scene.txt" "" levelcategory ${levelcategory_path})
get_filename_component(LEVEL_CODENAME ${levelcategory} NAME_WE)
set(SCENEFILE "${LEVEL_CODENAME}/scene.txt")
set(SCENEDEST "${LEVEL_CODENAME}.txt")
set(PODIR "${LEVEL_CODENAME}/po/")
set(HELPDIR "${LEVEL_CODENAME}/help/")
set(HELPDEST "")
message(STATUS "Managing translations for level '${LEVEL_CODENAME}'")
include(${LEVELS_I18N_PATH}/CMakeLists.txt)
file(GLOB chapter_dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${level_category_dir}/chapter*)
foreach(chapter_dir ${chapter_dirs})
add_chapter(${chapter_dir})
endforeach()
endfunction()
##
# Add chapter directory with all levels inside
##
function(add_chapter chapter_dir)
file(GLOB level_dirs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${chapter_dir}/level*)
foreach(level_dir ${level_dirs})
add_level(${level_dir})
endforeach()
endfunction()
##
# Add level directory
##
function(add_level level_dir)
if(PO4A)
generate_scene_i18n(translated_scene_path ${level_dir}/scene.txt)
else()
set(translated_scene_path ${level_dir}/scene.txt)
endif()
install(FILES ${translated_scene_path} DESTINATION ${LEVEL_INSTALL_DATA_DIR}/${level_dir})
# TODO install help files
# if(EXISTS ${level_dir}/help)
# install(DIRECTORY ${level_dir}/help DESTINATION ${LEVEL_INSTALL_DATA_DIR}/${level_dir})
# endif()
endfunction()
add_level_category(challenges)
add_level_category(exercises)
add_level_category(freemissions)
add_level_category(missions)