Ticket #7530: 0001-Added-localization-support-for-Cortex-app.patch

src/apps/cortex/AddOnHost/AddOnHostApp.cpp

@@ -35 +35 @@
 #include "AddOnHostProtocol.h"
 
 #include <Alert.h>
+#include <Catalog.h>
 #include <Debug.h>
 #include <MediaRoster.h>
 
 #include <cstdlib>
 #include <cstring>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnHost"
+
 __USE_CORTEX_NAMESPACE
 using namespace addon_host;
 
@@ -170 +174 @@
 {
     App app;
     if (argc < 2 || strcmp(argv[1], "--addon-host") != 0) {
-        BAlert* alert = new BAlert("Cortex AddOnHost",
-            "This program runs in the background, and is started automatically "
-            "by Cortex when necessary.  You probably don't want to start it manually.",
-            "Continue", "Quit");
+        BAlert* alert = new BAlert(B_TRANSLATE("Cortex AddOnHost"),
+            B_TRANSLATE("This program runs in the background, and is started automatically "
+            "by Cortex when necessary.  You probably don't want to start it manually."),
+            B_TRANSLATE("Continue"), B_TRANSLATE("Quit"));
         alert->SetShortcut(1, B_ESCAPE);
         int32 response = alert->Go();
 

src/apps/cortex/AddOnHost/Jamfile

@@ -9 +9 @@
 
 Application CortexAddOnHost :
     AddOnHostApp.cpp
-    : be media $(TARGET_LIBSTDC++) cortex_support.a
+    : be media $(TARGET_LIBSTDC++) cortex_support.a $(HAIKU_LOCALE_LIBS)
     : AddOnHost_Resource.rsrc
 ;
+
+DoCatalogs CorexAddOnHost :
+    application/x-vnd.Cortex.AddOnHost
+    :
+    AddOnHostApp.cpp
+;

src/apps/cortex/DormantNodeView/DormantNodeListItem.cpp

@@ -41 +41 @@
 
 // Application Kit
 #include <Application.h>
+// Locale Kit
+#include <Catalog.h>
 // Interface Kit
 #include <PopUpMenu.h>
 #include <MenuItem.h>
@@ -48 +50 @@
 #include <MediaRoster.h>
 #include <MediaAddOn.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexDormantNodeView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -267 +272 @@
     
     // Add the "Get Info" item
     BMessage *message = new BMessage(InfoWindowManager::M_INFO_WINDOW_REQUESTED);
-    menu->AddItem(new BMenuItem("Get info", message));
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Get info"), message));
 
     menu->SetTargetForItems(owner);
     owner->ConvertToScreen(&point);

src/apps/cortex/DormantNodeView/DormantNodeWindow.cpp

@@ -40 +40 @@
 
 // Application Kit
 #include <Application.h>
+// Locale Kit
+#include <Catalog.h>
 // Interface Kit
 #include <Screen.h>
 #include <ScrollBar.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexDormantNodeView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -65 +70 @@
 
 DormantNodeWindow::DormantNodeWindow(
     BWindow* parent)
-    : BWindow(s_initFrame, "Media add-ons",
+    : BWindow(s_initFrame, B_TRANSLATE("Media add-ons"),
               B_FLOATING_WINDOW_LOOK,
               B_FLOATING_SUBSET_WINDOW_FEEL,
               B_WILL_ACCEPT_FIRST_CLICK|B_AVOID_FOCUS|B_ASYNCHRONOUS_CONTROLS),

src/apps/cortex/DormantNodeView/Jamfile

@@ -15 +15 @@
     DormantNodeListItem.cpp
     DormantNodeView.cpp
     DormantNodeWindow.cpp
+    : be $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/InfoView/AppNodeInfoView.cpp

@@ -40 +40 @@
 
 // Application Kit
 #include <Roster.h>
+// Locale Kit
+#include <Catalog.h>
 // Media Kit
 #include <MediaNode.h>
 #include <MediaRoster.h>
@@ -49 +51 @@
 #include <File.h>
 #include <Path.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -65 +70 @@
     D_METHOD(("AppNodeInfoView::AppNodeInfoView()\n"));
 
     // adjust view properties
-    setSideBarWidth(be_plain_font->StringWidth(" File Format ") + 2 * InfoView::M_H_MARGIN);
-    setSubTitle("Application-Owned Node");
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("File format")) + 2 * InfoView::M_H_MARGIN);
+    setSubTitle(B_TRANSLATE("Application-Owned Node"));
 
     // add separator
     addField("", "");
@@ -82 +87 @@
         if ((appEntry.InitCheck() == B_OK)
          && (appEntry.GetName(appName) == B_OK))
         {
-            addField("Application", appName);
+            addField(B_TRANSLATE("Application"), appName);
         }
         BFile appFile(&appInfo.ref, B_READ_ONLY);
         if (appFile.InitCheck() == B_OK)
@@ -93 +98 @@
                 version_info appVersion;
                 if (appFileInfo.GetVersionInfo(&appVersion, B_APP_VERSION_KIND) == B_OK)
                 {
-                    addField("Version", appVersion.long_info);
+                    addField(B_TRANSLATE("Version"), appVersion.long_info);
                 }
             }
         }
-        addField("Signature", appInfo.signature);
+        addField(B_TRANSLATE("Signature"), appInfo.signature);
     }
 }
 

src/apps/cortex/InfoView/ConnectionInfoView.cpp

@@ -40 +40 @@
 // NodeManager
 #include "Connection.h"
 
+// Locale Kit
+#include <Catalog.h>
 // MediaKit
 #include <MediaDefs.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -55 +60 @@
 
 ConnectionInfoView::ConnectionInfoView(
     const Connection &connection)
-    : InfoView("Connection", "", 0),
+    : InfoView(B_TRANSLATE("Connection"), "", 0),
       m_source(connection.source()),
       m_destination(connection.destination())
 {
     D_METHOD(("ConnectionInfoView::ConnectionInfoView()\n"));
 
-    setSideBarWidth(be_plain_font->StringWidth(" Destination ")
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Destination"))
                     + 2 * InfoView::M_H_MARGIN);
     media_input input;
     media_output output;
@@ -72 +77 @@
         if (s.Length() > 0)
             s << " ";
         s << "(" << MediaString::getStringFor(output.source) << ")";
-        addField("Source", s);
+        addField(B_TRANSLATE("Source"), s);
     }
     if (connection.getInput(&input) == B_OK) {
         // add "Destination" field
@@ -81 +86 @@
         if (s.Length() > 0)
             s << " ";
         s << "(" << MediaString::getStringFor(input.destination) << ")";
-        addField("Destination", s);
+        addField(B_TRANSLATE("Destination"), s);
     }
 
     // add a separator field
     addField("", "");
 
     // add "Media Type" field
-    addField("Media Type", MediaString::getStringFor(connection.format().type));
+    addField(B_TRANSLATE("Media type"), MediaString::getStringFor(connection.format().type));
 
     // add the format fields
     _addFormatFields(connection.format());
@@ -110 +115 @@
     switch (format.type) {
         case B_MEDIA_RAW_AUDIO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Sample Rate ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Sample rate")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add "Format" field
             s = MediaString::forAudioFormat(format.u.raw_audio.format,
                                             format.u.raw_audio.valid_bits);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add "Sample Rate" field
             s = MediaString::forAudioFrameRate(format.u.raw_audio.frame_rate);
-            addField("Sample Rate", s);
+            addField(B_TRANSLATE("Sample rate"), s);
             // add "Channels" field
             s = MediaString::forAudioChannelCount(format.u.raw_audio.channel_count);
-            addField("Channels", s);
+            addField(B_TRANSLATE("Channels"), s);
             // add "Channel Mask" field
             s = MediaString::forAudioChannelMask(format.u.raw_audio.channel_mask);
-            addField("Channel Mask", s);
+            addField(B_TRANSLATE("Channel mask"), s);
             // add "Matrix Mask" field
             s = MediaString::forAudioMatrixMask(format.u.raw_audio.matrix_mask);
-            addField("Matrix Mask", s);
+            addField(B_TRANSLATE("Matrix mask"), s);
             // add the "Byte Order" field
             s = MediaString::forAudioByteOrder(format.u.raw_audio.byte_order);
-            addField("Byte Order", s);
+            addField(B_TRANSLATE("Byte order"), s);
             // add the "Buffer Size" field
             s = MediaString::forAudioBufferSize(format.u.raw_audio.buffer_size);
-            addField("Buffer Size", s);
+            addField(B_TRANSLATE("Buffer size"), s);
             break;
         }
         case B_MEDIA_RAW_VIDEO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Video Data Between ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Video data between")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Format" field
             s = MediaString::forVideoFormat(format.u.raw_video.display.format);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add the "Resolution" field
             s = MediaString::forVideoResolution(format.u.raw_video.display.line_width,
                                                 format.u.raw_video.display.line_count);
-            addField("Resolution", s);
+            addField(B_TRANSLATE("Resolution"), s);
             // add the "Field Rate" field
             s = MediaString::forVideoFieldRate(format.u.raw_video.field_rate,
                                                format.u.raw_video.interlace);
-            addField("Field Rate", s);
+            addField(B_TRANSLATE("Field rate"), s);
             // add the "Orientation" field
             s = MediaString::forVideoOrientation(format.u.raw_video.orientation);
-            addField("Orientation", s);
+            addField(B_TRANSLATE("Orientation"), s);
             // add the "Aspect Ratio" field
             s = MediaString::forVideoAspectRatio(format.u.raw_video.pixel_width_aspect,
                                                  format.u.raw_video.pixel_height_aspect);
-            addField("Aspect Ratio", s);
+            addField(B_TRANSLATE("Aspect ratio"), s);
             // add the "Active Lines" field
             s = MediaString::forVideoActiveLines(format.u.raw_video.first_active,
                                                  format.u.raw_video.last_active);
-            addField("Active Lines", s);
+            addField(B_TRANSLATE("Active lines"), s);
             // add the "Offset" field
             s = MediaString::forVideoOffset(format.u.raw_video.display.pixel_offset,
                                             format.u.raw_video.display.line_offset);            
-            addField("Offset", s);
+            addField(B_TRANSLATE("Offset"), s);
             break;
         }
         case B_MEDIA_ENCODED_AUDIO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Frame Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Frame size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Bit Rate" field
             s = MediaString::forAudioBitRate(format.u.encoded_audio.bit_rate);
-            addField("Bit Rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Frame Size" field
             s = MediaString::forAudioFrameSize(format.u.encoded_audio.frame_size);
-            addField("Frame Size", s);
+            addField(B_TRANSLATE("Frame size"), s);
             break;
         }
         case B_MEDIA_ENCODED_VIDEO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Frame Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Frame size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Bit Rate" field
             s = MediaString::forVideoBitRate(format.u.encoded_video.avg_bit_rate,
                                              format.u.encoded_video.max_bit_rate);
-            addField("Bit Rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Frame Size" field
             s = MediaString::forVideoFrameSize(format.u.encoded_video.frame_size);
-            addField("Frame Size", s);
+            addField(B_TRANSLATE("Frame size"), s);
             // add the "History" field
             s = MediaString::forVideoHistory(format.u.encoded_video.forward_history,
                                              format.u.encoded_video.backward_history);
-            addField("History", s);
+            addField(B_TRANSLATE("History"), s);
             break;
         }
         case B_MEDIA_MULTISTREAM: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Chunk Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Chunk size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Format" field
             s = MediaString::forMultistreamFormat(format.u.multistream.format);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add the "Bit Rate" field
             s = MediaString::forMultistreamBitRate(format.u.multistream.avg_bit_rate,
                                                    format.u.multistream.max_bit_rate);
-            addField("Bit Rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Chunk Size" field
             s = MediaString::forMultistreamChunkSize(format.u.multistream.avg_chunk_size,
                                                      format.u.multistream.max_chunk_size);
-            addField("Chunk Size", s);
+            addField(B_TRANSLATE("Chunk size"), s);
             // add the "Flags" field
             s = MediaString::forMultistreamFlags(format.u.multistream.flags);
-            addField("Flags", s);
+            addField(B_TRANSLATE("Flags"), s);
             break;
         }
         default: {

src/apps/cortex/InfoView/DormantNodeInfoView.cpp

@@ -38 +38 @@
 #include "MediaIcon.h"
 #include "MediaString.h"
 
+// Locale Kit
+#include <Catalog.h>
 // Media Kit
 #include <MediaAddOn.h>
 #include <MediaRoster.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -53 +58 @@
 
 DormantNodeInfoView::DormantNodeInfoView(
     const dormant_node_info &info)
-    : InfoView(info.name, "Dormant media node",
+    : InfoView(info.name, B_TRANSLATE("Dormant media node"),
                new MediaIcon(info, B_LARGE_ICON)),
       m_addOnID(info.addon),
       m_flavorID(info.flavor_id)
@@ -61 +66 @@
     D_METHOD(("DormantNodeInfoView::DormantNodeInfoView()\n"));
 
     // adjust view properties
-    setSideBarWidth(be_plain_font->StringWidth(" Output Formats ") + 2 * InfoView::M_H_MARGIN);
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Output formats")) + 2 * InfoView::M_H_MARGIN);
 
     BString s;
 
     // add the "AddOn ID" field
     s = "";
     s << info.addon;
-    addField("AddOn ID", s);
+    addField(B_TRANSLATE("AddOn ID"), s);
 
     // add the "Flavor ID" field
     s = "";
     s << info.flavor_id;
-    addField("Flavor ID", s);
+    addField(B_TRANSLATE("Flavor ID"), s);
     
     // add separator field
     addField("", "");
@@ -84 +89 @@
     {
         // add the "Description" field
         s = flavorInfo.info;
-        addField("Description", s);
+        addField(B_TRANSLATE("Description"), s);
 
         // add "Kinds" field
-        addField("Kinds", MediaString::getStringFor(static_cast<node_kind>(flavorInfo.kinds)));
+        addField(B_TRANSLATE("Kinds"), MediaString::getStringFor(static_cast<node_kind>(flavorInfo.kinds)));
 
         // add "Flavor Flags" field
-        addField("Flavor flags", "?");
+        addField(B_TRANSLATE("Flavor flags"), "?");
 
         // add "Max. instances" field
         if (flavorInfo.possible_count > 0)
@@ -100 +105 @@
         }
         else
         {
-            s = "Any number";
+            s = B_TRANSLATE("Any number");
         }
-        addField("Max. instances", s);
+        addField(B_TRANSLATE("Max. instances"), s);
 
         // add "Input Formats" field
         if (flavorInfo.in_format_count > 0)
         {
             if (flavorInfo.in_format_count == 1)
             {
-                addField("Input format", MediaString::getStringFor(flavorInfo.in_formats[0], false));
+                addField(B_TRANSLATE("Input format"), MediaString::getStringFor(flavorInfo.in_formats[0], false));
             }
             else
             {
-                addField("Input formats", "");
+                addField(B_TRANSLATE("Input formats"), "");
                 for (int32 i = 0; i < flavorInfo.in_format_count; i++)
                 {
                     s = "";
@@ -128 +133 @@
         {
             if (flavorInfo.out_format_count == 1)
             {
-                addField("Output format", MediaString::getStringFor(flavorInfo.out_formats[0], false));
+                addField(B_TRANSLATE("Output format"), MediaString::getStringFor(flavorInfo.out_formats[0], false));
             }
             else
             {
-                addField("Output formats", "");
+                addField(B_TRANSLATE("Output formats"), "");
                 for (int32 i = 0; i < flavorInfo.out_format_count; i++)
                 {
                     s = "";

src/apps/cortex/InfoView/EndPointInfoView.cpp

@@ -38 +38 @@
 #include "MediaIcon.h"
 #include "MediaString.h"
 
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -49 +55 @@
 
 EndPointInfoView::EndPointInfoView(
     const media_input &input)
-    : InfoView(input.name, "Media input", 0),
+    : InfoView(input.name, B_TRANSLATE("Media input"), 0),
       m_output(false),
       m_port(input.destination.port),
       m_id(input.destination.id) {
     D_METHOD(("EndPointInfoView::EndPointInfoView(input)\n"));
 
-    setSideBarWidth(be_plain_font->StringWidth(" Destination ") 
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Destination")) 
                     + 2 * InfoView::M_H_MARGIN);
 
     // add "Source" field
-    addField("Source", MediaString::getStringFor(input.source));
+    addField(B_TRANSLATE("Source"), MediaString::getStringFor(input.source));
 
     // add "Destination" field
-    addField("Destination", MediaString::getStringFor(input.destination));
+    addField(B_TRANSLATE("Destination"), MediaString::getStringFor(input.destination));
     
     // add a separator field
     addField("", "");
 
     // add "Media Type" field
-    addField("Media type", MediaString::getStringFor(input.format.type));
+    addField(B_TRANSLATE("Media type"), MediaString::getStringFor(input.format.type));
 
     _addFormatFields(input.format);
 }
 
 EndPointInfoView::EndPointInfoView(
     const media_output &output)
-    : InfoView(output.name, "Media output", 0),
+    : InfoView(output.name, B_TRANSLATE("Media output"), 0),
       m_output(true),
       m_port(output.source.port),
       m_id(output.source.id) {
     D_METHOD(("EndPointInfoView::EndPointInfoView(output)\n"));
 
-    setSideBarWidth(be_plain_font->StringWidth(" Destination ") 
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Destination")) 
                     + 2 * InfoView::M_H_MARGIN);
 
     // add "Source" field
-    addField("Source", MediaString::getStringFor(output.source));
+    addField(B_TRANSLATE("Source"), MediaString::getStringFor(output.source));
 
     // add "Destination" field
-    addField("Destination", MediaString::getStringFor(output.destination));
+    addField(B_TRANSLATE("Destination"), MediaString::getStringFor(output.destination));
     
     // add a separator field
     addField("", "");
 
     // add "Media Type" field
-    addField("Media type", MediaString::getStringFor(output.format.type));
+    addField(B_TRANSLATE("Media type"), MediaString::getStringFor(output.format.type));
 
     _addFormatFields(output.format);
 }
@@ -140 +146 @@
     switch (format.type) {
         case B_MEDIA_RAW_AUDIO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Sample Rate ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Sample rate")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add "Format" field
             s = MediaString::forAudioFormat(format.u.raw_audio.format,
                                             format.u.raw_audio.valid_bits);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add "Sample Rate" field
             s = MediaString::forAudioFrameRate(format.u.raw_audio.frame_rate);
-            addField("Sample rate", s);
+            addField(B_TRANSLATE("Sample rate"), s);
             // add "Channels" field
             s = MediaString::forAudioChannelCount(format.u.raw_audio.channel_count);
-            addField("Channels", s);
+            addField(B_TRANSLATE("Channels"), s);
             // add "Channel Mask" field
             s = MediaString::forAudioChannelMask(format.u.raw_audio.channel_mask);
-            addField("Channel mask", s);
+            addField(B_TRANSLATE("Channel mask"), s);
             // add "Matrix Mask" field
             s = MediaString::forAudioMatrixMask(format.u.raw_audio.matrix_mask);
-            addField("Matrix mask", s);
+            addField(B_TRANSLATE("Matrix mask"), s);
             // add the "Byte Order" field
             s = MediaString::forAudioByteOrder(format.u.raw_audio.byte_order);
-            addField("Byte order", s);
+            addField(B_TRANSLATE("Byte order"), s);
             // add the "Buffer Size" field
             s = MediaString::forAudioBufferSize(format.u.raw_audio.buffer_size);
-            addField("Buffer size", s);
+            addField(B_TRANSLATE("Buffer size"), s);
             break;
         }
         case B_MEDIA_RAW_VIDEO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Video Data Between ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Video data between")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Format" field
             s = MediaString::forVideoFormat(format.u.raw_video.display.format);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add the "Resolution" field
             s = MediaString::forVideoResolution(format.u.raw_video.display.line_width,
                                                 format.u.raw_video.display.line_count);
-            addField("Resolution", s);
+            addField(B_TRANSLATE("Resolution"), s);
             // add the "Field Rate" field
             s = MediaString::forVideoFieldRate(format.u.raw_video.field_rate,
                                                format.u.raw_video.interlace);
-            addField("Field rate", s);
+            addField(B_TRANSLATE("Field rate"), s);
             // add the "Orientation" field
             s = MediaString::forVideoOrientation(format.u.raw_video.orientation);
-            addField("Orientation", s);
+            addField(B_TRANSLATE("Orientation"), s);
             // add the "Aspect Ratio" field
             s = MediaString::forVideoAspectRatio(format.u.raw_video.pixel_width_aspect,
                                                  format.u.raw_video.pixel_height_aspect);
-            addField("Aspect ratio", s);
+            addField(B_TRANSLATE("Aspect ratio"), s);
             // add the "Active Lines" field
             s = MediaString::forVideoActiveLines(format.u.raw_video.first_active,
                                                  format.u.raw_video.last_active);
-            addField("Active lines", s);
+            addField(B_TRANSLATE("Active lines"), s);
             // add the "Offset" field
             s = MediaString::forVideoOffset(format.u.raw_video.display.pixel_offset,
                                             format.u.raw_video.display.line_offset);            
-            addField("Offset", s);
+            addField(B_TRANSLATE("Offset"), s);
             break;
         }
         case B_MEDIA_ENCODED_AUDIO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Frame Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Frame size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Bit Rate" field
             s = MediaString::forAudioBitRate(format.u.encoded_audio.bit_rate);
-            addField("Bit rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Frame Size" field
             s = MediaString::forAudioFrameSize(format.u.encoded_audio.frame_size);
-            addField("Frame size", s);
+            addField(B_TRANSLATE("Frame size"), s);
             break;
         }
         case B_MEDIA_ENCODED_VIDEO: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Frame Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Frame size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Bit Rate" field
             s = MediaString::forVideoBitRate(format.u.encoded_video.avg_bit_rate,
                                              format.u.encoded_video.max_bit_rate);
-            addField("Bit rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Frame Size" field
             s = MediaString::forVideoFrameSize(format.u.encoded_video.frame_size);
-            addField("Frame size", s);
+            addField(B_TRANSLATE("Frame size"), s);
             // add the "History" field
             s = MediaString::forVideoHistory(format.u.encoded_video.forward_history,
                                              format.u.encoded_video.backward_history);
-            addField("History", s);
+            addField(B_TRANSLATE("History"), s);
             break;
         }
         case B_MEDIA_MULTISTREAM: {
             // adjust view properties
-            setSideBarWidth(be_plain_font->StringWidth(" Chunk Size ") + 2 * InfoView::M_H_MARGIN);
+            setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Chunk size")) + 2 * InfoView::M_H_MARGIN);
             BString s;
             // add the "Format" field
             s = MediaString::forMultistreamFormat(format.u.multistream.format);
-            addField("Format", s);
+            addField(B_TRANSLATE("Format"), s);
             // add the "Bit Rate" field
             s = MediaString::forMultistreamBitRate(format.u.multistream.avg_bit_rate,
                                                    format.u.multistream.max_bit_rate);
-            addField("Bit rate", s);
+            addField(B_TRANSLATE("Bit rate"), s);
             // add the "Chunk Size" field
             s = MediaString::forMultistreamChunkSize(format.u.multistream.avg_chunk_size,
                                                      format.u.multistream.max_chunk_size);
-            addField("Chunk size", s);
+            addField(B_TRANSLATE("Chunk size"), s);
             // add the "Flags" field
             s = MediaString::forMultistreamFlags(format.u.multistream.flags);
-            addField("Flags", s);
+            addField(B_TRANSLATE("Flags"), s);
             break;
         }
         default: {

src/apps/cortex/InfoView/FileNodeInfoView.cpp

@@ -36 +36 @@
 #include "MediaString.h"
 #include "NodeRef.h"
 
+#include <Catalog.h>
 #include <MediaFile.h>
 #include <MediaNode.h>
 #include <MediaRoster.h>
 #include <MediaTrack.h>
 #include <TimeCode.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -58 +62 @@
     D_METHOD(("FileNodeInfoView::FileNodeInfoView()\n"));
 
     // adjust view properties
-    setSideBarWidth(be_plain_font->StringWidth(" File Format ") + 2 * InfoView::M_H_MARGIN);
-    setSubTitle("Live File-Interface Node");
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("File format")) + 2 * InfoView::M_H_MARGIN);
+    setSubTitle(B_TRANSLATE("Live File-Interface Node"));
 
     // if a ref is set for this file-interface display some info
     // thru MediaFile and set the title appropriatly
@@ -82 +86 @@
             {
                 s = "";
                 s << format.pretty_name << " (" << format.mime_type << ")";
-                addField("File Format", s);
+                addField(B_TRANSLATE("File format"), s);
             }
             
             // add "Copyright" field
@@ -90 +94 @@
             if (copyRight)
             {
                 s = copyRight;
-                addField("Copyright", s);
+                addField(B_TRANSLATE("Copyright"), s);
             }
     
             // add "Tracks" list
             if (file.CountTracks() > 0)
             {
-                addField("Tracks", "");
+                addField(B_TRANSLATE("Tracks"), "");
                 for (int32 i = 0; i < file.CountTracks(); i++)
                 {
                     BString label;
@@ -117 +121 @@
                         media_codec_info codec;
                         if (track->GetCodecInfo(&codec) == B_OK)
                         {
-                            s << "\n- Codec: " << codec.pretty_name;
+                            s << B_TRANSLATE("\n- Codec: ") << codec.pretty_name;
                             if (codec.id > 0)
                             {
-                                s << " (ID: " << codec.id << ")";
+                                s << B_TRANSLATE(" (ID: ") << codec.id << ")";
                             }
                         }
                     }
@@ -131 +135 @@
                     us_to_timecode(duration, &hours, &minutes, &seconds, &frames);
                     char buffer[64];
                     sprintf(buffer, "%02d:%02d:%02d:%02d", hours, minutes, seconds, frames);
-                    s << "\n- Duration: " << buffer;
+                    s << B_TRANSLATE("\n- Duration: ") << buffer;
                     
                     // add quality
                     float quality;
                     if (track->GetQuality(&quality) == B_OK)
                     {
-                        s << "\n- Quality: " << quality;
+                        s << B_TRANSLATE("\n- Quality: ") << quality;
                     }
                     addField(label, s);
                 }
@@ -153 +157 @@
     {
         // set title
         title = ref->name();
-        title += " (no file)";
+        title += B_TRANSLATE(" (no file)");
     }
     setTitle(title);
 }

src/apps/cortex/InfoView/InfoView.cpp

@@ -36 +36 @@
 
 #include "array_delete.h"
 
+// Locale Kit
+#include <Catalog.h>
 // Interface Kit
 #include <Bitmap.h>
 #include <Region.h>
@@ -48 +50 @@
 // Support Kit
 #include <List.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -176 +181 @@
 
     // adjust the windows title
     BString title = m_title;
-    title << " info";
+    title << B_TRANSLATE(" info");
     Window()->SetTitle(title.String());
     
     // calculate the area occupied by title, subtitle and icon

src/apps/cortex/InfoView/Jamfile

@@ -18 +18 @@
     InfoWindow.cpp
     InfoWindowManager.cpp
     LiveNodeInfoView.cpp
+    : be $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/InfoView/LiveNodeInfoView.cpp

@@ -41 +41 @@
 #include "MediaIcon.h"
 #include "MediaString.h"
 
+// Locale Kit
+#include <Catalog.h>
+
 // Media Kit
 #include <MediaNode.h>
 
 // Interface Kit
 #include <Window.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexInfoView"
+
 __USE_CORTEX_NAMESPACE
 
 #include <Debug.h>
@@ -59 +65 @@
 
 LiveNodeInfoView::LiveNodeInfoView(
     const NodeRef *ref)
-    : InfoView(ref->name(), "Live Media Node",
+    : InfoView(ref->name(), B_TRANSLATE("Live media node"),
                new MediaIcon(ref->nodeInfo(), B_LARGE_ICON)),
       m_nodeID(ref->id())
 {
     D_METHOD(("LiveNodeInfoView::LiveNodeInfoView()\n"));
 
     // adjust view properties
-    setSideBarWidth(be_plain_font->StringWidth(" Run Mode ") + 2 * InfoView::M_H_MARGIN);
+    setSideBarWidth(be_plain_font->StringWidth(B_TRANSLATE("Run mode")) + 2 * InfoView::M_H_MARGIN);
 
     // add "Node ID" field
     BString s;
     s << ref->id();
-    addField("Node ID", s);
+    addField(B_TRANSLATE("Node ID"), s);
 
     // add "Port" field
     s = "";
@@ -81 +87 @@
     {
         s << " (" << portInfo.name << ")";
     }
-    addField("Port", s);
+    addField(B_TRANSLATE("Port"), s);
 
     // add separator field
     addField("", "");
 
     // add "Kinds" field
-    addField("Kinds", MediaString::getStringFor(static_cast<node_kind>(ref->kind())));
+    addField(B_TRANSLATE("Kinds"), MediaString::getStringFor(static_cast<node_kind>(ref->kind())));
 
     // add "Run Mode" field
     BMediaNode::run_mode runMode = static_cast<BMediaNode::run_mode>(ref->runMode());
@@ -99 +105 @@
             runMode = group->runMode();
         }
     }
-    addField("Run Mode", MediaString::getStringFor(runMode));
+    addField(B_TRANSLATE("Run mode"), MediaString::getStringFor(runMode));
 
     // add "Latency" field
     bigtime_t latency;
@@ -114 +120 @@
         {
             s = "?";
         }
-        addField("Latency", s);
+        addField(B_TRANSLATE("Latency"), s);
     }
 }
 

src/apps/cortex/MediaRoutingView/Jamfile

@@ -22 +22 @@
     MediaNodePanel.cpp
     MediaRoutingView.cpp
     MediaWire.cpp
+    : $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/MediaRoutingView/MediaJack.cpp

@@ -51 +51 @@
 #include <Bitmap.h>
 #include <MenuItem.h>
 #include <PopUpMenu.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexMediaRoutingView"
 
 __USE_CORTEX_NAMESPACE
 
@@ -88 +93 @@
     D_METHOD(("MediaJack::MediaJack()\n"));
     makeSelectable(false);
     if (m_label == "")
-        m_label = "Input";
+        m_label = B_TRANSLATE("Input");
     _updateAbbreviation();
 }
 
@@ -108 +113 @@
     D_METHOD(("MediaJack::MediaJack()\n"));
     makeSelectable(false);
     if (m_label == "")
-        m_label = "Output";
+        m_label = B_TRANSLATE("Output");
     _updateAbbreviation();
 }
 
@@ -749 +754 @@
         BMessage *message = new BMessage(InfoWindowManager::M_INFO_WINDOW_REQUESTED);
         message->AddData("input", B_RAW_TYPE,
                          reinterpret_cast<const void *>(&input), sizeof(input));
-        menu->AddItem(item = new BMenuItem("Get info", message));
+        menu->AddItem(item = new BMenuItem(B_TRANSLATE("Get info"), message));
     }
     else if (isOutput())
     {
@@ -758 +763 @@
         BMessage *message = new BMessage(InfoWindowManager::M_INFO_WINDOW_REQUESTED);
         message->AddData("output", B_RAW_TYPE,
                          reinterpret_cast<const void *>(&output), sizeof(output));
-        menu->AddItem(item = new BMenuItem("Get info", message));
+        menu->AddItem(item = new BMenuItem(B_TRANSLATE("Get info"), message));
     }
 
     menu->SetTargetForItems(view());

src/apps/cortex/MediaRoutingView/MediaNodePanel.cpp

@@ -62 +62 @@
 // Media Kit
 #include <MediaDefs.h>
 #include <MediaRoster.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexMediaNodePanel"
 
 using namespace std;
 
@@ -564 +569 @@
 
     // add the "Tweak Parameters" item
     message = new BMessage(MediaRoutingView::M_NODE_TWEAK_PARAMETERS);
-    menu->AddItem(item = new BMenuItem("Tweak parameters", message, 'P'));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Tweak parameters"), message, 'P'));
     if (!(ref->kind() & B_CONTROLLABLE))
     {
         item->SetEnabled(false);
@@ -572 +577 @@
 
     message = new BMessage(InfoWindowManager::M_INFO_WINDOW_REQUESTED);
     message->AddInt32("nodeID", ref->id());
-    menu->AddItem(new BMenuItem("Get info", message, 'I'));
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Get info"), message, 'I'));
     menu->AddSeparatorItem();
 
-    menu->AddItem(item = new BMenuItem("Release", new BMessage(MediaRoutingView::M_DELETE_SELECTION), 'T'));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Release"), new BMessage(MediaRoutingView::M_DELETE_SELECTION), 'T'));
     if (!ref->isInternal())
     {
         item->SetEnabled(false);
@@ -585 +590 @@
     // add the "Cycle" item
     message = new BMessage(MediaRoutingView::M_NODE_CHANGE_CYCLING);
     message->AddBool("cycle", !ref->isCycling());
-    menu->AddItem(item = new BMenuItem("Cycle", message));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Cycle"), message));
     item->SetMarked(ref->isCycling());
     if (ref->flags() & NodeRef::NO_SEEK)
     {
@@ -593 +598 @@
     }
 
     // add the "Run Mode" sub menu
-    BMenu *subMenu = new BMenu("Run mode");
+    BMenu *subMenu = new BMenu(B_TRANSLATE("Run mode"));
     subMenu->SetFont(be_plain_font);
     for (uint32 runMode = 1; runMode <= BMediaNode::B_RECORDING; runMode++)
     {
@@ -615 +620 @@
     subMenu->AddSeparatorItem();
     message = new BMessage(MediaRoutingView::M_NODE_CHANGE_RUN_MODE);
     message->AddInt32("run_mode", 0);
-    subMenu->AddItem(item = new BMenuItem("(same as group)", message));
+    subMenu->AddItem(item = new BMenuItem(B_TRANSLATE("(same as group)"), message));
     if (ref->group() == 0)
     {
         item->SetEnabled(false);
@@ -628 +633 @@
     subMenu->SetTargetForItems(view());
     
     // [c.lenz 24dec99] hide rarely used commands in a 'Advanced' submenu
-    subMenu = new BMenu("Advanced");
+    subMenu = new BMenu(B_TRANSLATE("Advanced"));
     subMenu->SetFont(be_plain_font);
     // [e.moon 5dec99] ad-hoc timesource support
     if(ref->kind() & B_TIME_SOURCE) {
         message = new BMessage(MediaRoutingView::M_NODE_START_TIME_SOURCE);
         message->AddInt32("nodeID", ref->id());
         subMenu->AddItem(new BMenuItem(
-            "Start time source",
+            B_TRANSLATE("Start time source"),
             message));
         message = new BMessage(MediaRoutingView::M_NODE_START_TIME_SOURCE);
         message->AddInt32("nodeID", ref->id());
         subMenu->AddItem(new BMenuItem(
-            "Stop time source",
+            B_TRANSLATE("Stop time source"),
             message));
     }
     // [c.lenz 24dec99] support for BControllable::StartControlPanel()
@@ -648 +653 @@
         if (subMenu->CountItems() > 0)
             subMenu->AddSeparatorItem();
         message = new BMessage(MediaRoutingView::M_NODE_START_CONTROL_PANEL);
-        subMenu->AddItem(new BMenuItem("Start Control Panel", message,
+        subMenu->AddItem(new BMenuItem(B_TRANSLATE("Start control panel"), message,
                                        'P', B_COMMAND_KEY | B_SHIFT_KEY));
     }
     // [em 1feb00] group tweaks
@@ -662 +667 @@
             subMenu->AddSeparatorItem();
         subMenu->AddItem(
             new BMenuItem(
-                isLocked ? "Unlock group" : "Lock group", message));
+                isLocked ? B_TRANSLATE("Unlock group") : B_TRANSLATE("Lock group"), message));
     }
     
     if (subMenu->CountItems() > 0)

src/apps/cortex/MediaRoutingView/MediaRoutingView.cpp

@@ -71 +71 @@
 // Translation Kit
 #include <BitmapStream.h>
 #include <TranslatorRoster.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexMediaRoutingView"
 
 __USE_CORTEX_NAMESPACE
 
@@ -268 +273 @@
                             m_lastDropPoint = Align(ConvertFromScreen(dropPoint - dropOffset));
                         } else {
                             BString s;
-                            s << "Could not instantiate '" << info.name << "'";
+                            s << B_TRANSLATE("Could not instantiate") << " '" << info.name << "'";
                             showErrorMessage(s, error);
                         }
                     }   
@@ -942 +947 @@
     BMenuItem *item;
     BMessage *message = new BMessage(M_LAYOUT_CHANGED);
     message->AddInt32("layout", M_ICON_VIEW);
-    menu->AddItem(item = new BMenuItem("Icon view", message));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Icon view"), message));
     if (m_layout == M_ICON_VIEW)
     {
         item->SetMarked(true);
     }
     message = new BMessage(M_LAYOUT_CHANGED);
     message->AddInt32("layout", M_MINI_ICON_VIEW);
-    menu->AddItem(item = new BMenuItem("Mini icon view", message));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Mini icon view"), message));
     if (m_layout == M_MINI_ICON_VIEW)
     {
         item->SetMarked(true);
@@ -957 +962 @@
     menu->AddSeparatorItem();
 
     // add 'CleanUp' command
-    menu->AddItem(new BMenuItem("Clean up", new BMessage(M_CLEANUP_REQUESTED), 'K'));
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Clean up"), new BMessage(M_CLEANUP_REQUESTED), 'K'));
 
     // add 'Select All' command
-    menu->AddItem(new BMenuItem("Select all", new BMessage(M_SELECT_ALL), 'A'));
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Select all"), new BMessage(M_SELECT_ALL), 'A'));
 
     menu->SetTargetForItems(this);
     ConvertToScreen(&point);
@@ -986 +991 @@
     BMessenger messenger(0, Window());
     if (!messenger.IsValid()
      || (messenger.SendMessage(&message) != B_OK)) {
-        BAlert *alert = new BAlert("Error", text.String(), "OK", 0, 0,
+        BAlert *alert = new BAlert("Error", text.String(), B_TRANSLATE("OK"), 0, 0,
                                    B_WIDTH_AS_USUAL, B_WARNING_ALERT);
         alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
         alert->Go();
@@ -1465 +1470 @@
             font_height fh;
             be_plain_font->GetHeight(&fh);
             labelWidth = 4 * MediaNodePanel::M_LABEL_H_MARGIN
-                         + be_plain_font->StringWidth(" Be Audio Mixer ");
+                         + be_plain_font->StringWidth(B_TRANSLATE("Be Audio Mixer"));
             bodyWidth = 2 * MediaNodePanel::M_BODY_H_MARGIN + B_LARGE_ICON
                         + 2 * MediaJack::M_DEFAULT_WIDTH;
             labelHeight = 2 * MediaNodePanel::M_LABEL_V_MARGIN
@@ -1488 +1493 @@
             font_height fh;
             be_plain_font->GetHeight(&fh);
             labelWidth = 4 * MediaNodePanel::M_LABEL_H_MARGIN
-                         + be_plain_font->StringWidth(" Be Audio Mixer ");
+                         + be_plain_font->StringWidth(B_TRANSLATE("Be Audio Mixer"));
             bodyWidth = 2 * MediaNodePanel::M_BODY_H_MARGIN + B_MINI_ICON;
             labelHeight = 3 * MediaNodePanel::M_LABEL_V_MARGIN
                           + fh.ascent + fh.descent + fh.leading
@@ -1532 +1537 @@
     NodeRef* videoIn = manager->videoInputNode();
     if (videoIn)
     {
-        group = manager->createGroup("Video input");
+        group = manager->createGroup(B_TRANSLATE("Video input"));
         group->setRunMode(BMediaNode::B_RECORDING);
         group->addNode(videoIn);
     }
     NodeRef* audioIn = manager->audioInputNode();
     if (audioIn)
     {
-        group = manager->createGroup("Audio input");
+        group = manager->createGroup(B_TRANSLATE("Audio input"));
         group->setRunMode(BMediaNode::B_RECORDING);
         group->addNode(audioIn);
     }
     NodeRef* videoOut = manager->videoOutputNode();
     if (videoOut)
     {
-        group = manager->createGroup("Video output");
+        group = manager->createGroup(B_TRANSLATE("Video output"));
         group->addNode(videoOut);
     }
 }
@@ -1673 +1678 @@
                 if (error)
                 {
                     BString s;
-                    s << "Could not release '" << panel->ref->name() << "'";
+                    s << B_TRANSLATE("Could not release") << " '" << panel->ref->name() << "'";
                     showErrorMessage(s, error);
                 }
             }           
@@ -1689 +1694 @@
                 status_t error = manager->disconnect(wire->connection);
                 if (error)
                 {
-                    showErrorMessage("Could not disconnect", error);
+                    showErrorMessage(B_TRANSLATE("Could not disconnect"), error);
                 }
             }
         }
@@ -1753 +1758 @@
                             BEntry entry(ref);
                             entry.GetName(fileName);
                             BString s;
-                            s << "Could not load '" << fileName << "'";
+                            s << B_TRANSLATE("Could not load") << " '" << fileName << "'";
                             showErrorMessage(s, error);
                         }
                     }

src/apps/cortex/MediaRoutingView/MediaWire.cpp

@@ -51 +51 @@
 #include <PopUpMenu.h>
 // Media Kit
 #include <MediaDefs.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexMediaRoutingView"
 
 __USE_CORTEX_NAMESPACE
 
@@ -322 +327 @@
     BMessage *message = new BMessage(InfoWindowManager::M_INFO_WINDOW_REQUESTED);
     message->AddData("connection", B_RAW_TYPE, 
                      reinterpret_cast<const void *>(&output), sizeof(output));
-    menu->AddItem(item = new BMenuItem("Get info", message, 'I'));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Get info"), message, 'I'));
 
     // add the "Disconnect" item
-    menu->AddItem(item = new BMenuItem("Disconnect", new BMessage(MediaRoutingView::M_DELETE_SELECTION), 'T'));
+    menu->AddItem(item = new BMenuItem(B_TRANSLATE("Disconnect"), new BMessage(MediaRoutingView::M_DELETE_SELECTION), 'T'));
     if (connection.flags() & Connection::LOCKED)
     {
         item->SetEnabled(false);

src/apps/cortex/NodeManager/Jamfile

@@ -15 +15 @@
     NodeGroup.cpp
     NodeRef.cpp
     NodeSyncThread.cpp
+    : $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/NodeManager/NodeManager.cpp

@@ -46 +46 @@
 #include <functional>
 #include <list>
 #include <set>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexNodeManager"
 
 #include "set_tools.h"
 #include "functional_tools.h"
@@ -406 +411 @@
 //
 }
 
-const char* const           NodeManager::s_defaultGroupPrefix = "No Name";
-const char* const           NodeManager::s_timeSourceGroup = "Time Sources";
-const char* const           NodeManager::s_audioInputGroup = "System Audio Input";
-const char* const           NodeManager::s_videoInputGroup = "System Video Input";
-const char* const           NodeManager::s_audioMixerGroup = "System Audio Mixer";
-const char* const           NodeManager::s_videoOutputGroup = "System Video Output";
+const char* const           NodeManager::s_defaultGroupPrefix = B_TRANSLATE("No name");
+const char* const           NodeManager::s_timeSourceGroup = B_TRANSLATE("Time sources");
+const char* const           NodeManager::s_audioInputGroup = B_TRANSLATE("System audio input");
+const char* const           NodeManager::s_videoInputGroup = B_TRANSLATE("System video input");
+const char* const           NodeManager::s_audioMixerGroup = B_TRANSLATE("System audio mixer");
+const char* const           NodeManager::s_videoOutputGroup = B_TRANSLATE("System video output");
 
 NodeManager::NodeManager(
     bool                                                    useAddOnHost) :

src/apps/cortex/ParameterView/Jamfile

@@ -12 +12 @@
     ParameterWindowManager.cpp
     ParameterWindow.cpp
     ParameterContainerView.cpp
+    : $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/ParameterView/ParameterWindow.cpp

@@ -54 +54 @@
 #include <Path.h>
 // Support Kit
 #include <String.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexParameterWindow"
 
 __USE_CORTEX_NAMESPACE
 
@@ -83 +88 @@
 
     // add the nodes name to the title
     {
-        char* title = new char[strlen(nodeInfo.name) + strlen(" parameters") + 1];
-        sprintf(title, "%s parameters", nodeInfo.name);
+        char* title = new char[strlen(nodeInfo.name) + strlen(B_TRANSLATE(" parameters")) + 1];
+        sprintf(title, B_TRANSLATE("%s parameters"), nodeInfo.name);
         SetTitle(title);
         delete [] title;
     }
     // add the menu bar
     BMenuBar *menuBar = new BMenuBar(Bounds(), "ParameterWindow MenuBar");
 
-    BMenu *menu = new BMenu("Window");
-    menu->AddItem(new BMenuItem("Start control panel",
+    BMenu *menu = new BMenu(B_TRANSLATE("Window"));
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Start control panel"),
                                 new BMessage(M_START_CONTROL_PANEL),
                                 'P', B_COMMAND_KEY | B_SHIFT_KEY));
     menu->AddSeparatorItem();
-    menu->AddItem(new BMenuItem("Close",
+    menu->AddItem(new BMenuItem(B_TRANSLATE("Close"),
                                 new BMessage(B_QUIT_REQUESTED),
                                 'W', B_COMMAND_KEY));
     menuBar->AddItem(menu);
 
     // future Media Theme selection capabilities go here
-    menu = new BMenu("Themes");
+    menu = new BMenu(B_TRANSLATE("Themes"));
     BMessage *message = new BMessage(M_THEME_SELECTED);
     BMediaTheme *theme = BMediaTheme::PreferredTheme();
     message->AddInt32("themeID", theme->ID());
@@ -158 +163 @@
             D_MESSAGE((" -> M_START_CONTROL_PANEL\n"));
             status_t error = _startControlPanel();
             if (error) {
-                BString s = "Could not start control panel";
+                BString s = B_TRANSLATE("Could not start control panel");
                 s << " (" << strerror(error) << ")";
-                BAlert *alert = new BAlert("", s.String(), "OK", 0, 0,
+                BAlert *alert = new BAlert("", s.String(), B_TRANSLATE("OK"), 0, 0,
                                            B_WIDTH_AS_USUAL, B_WARNING_ALERT);
                 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                 alert->Go(0);

src/apps/cortex/RouteApp/Jamfile

@@ -41 +41 @@
     cortex_support.a
     be media tracker translation
     libexpat.a
-    $(TARGET_LIBSTDC++)
+    $(TARGET_LIBSTDC++) $(HAIKU_LOCALE_LIBS)
     : ../Resource.rdef
 ;
+
+DoCatalogs Cortex :
+    application/x-vnd.Cortex.Route
+    :
+    RouteAppNodeManager.cpp
+    RouteWindow.cpp
+    ;

src/apps/cortex/RouteApp/RouteAppNodeManager.cpp

@@ -62 +62 @@
 
 #include "set_tools.h"
 
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexRouteApp"
+
 using namespace std;
 
 __USE_CORTEX_NAMESPACE
@@ -170 +176 @@
 
     // prepare the log message
     BMessage logMsg(M_LOG);
-    BString title = "Node '";
-    title << ref->name() << "' created";
+    BString title = B_TRANSLATE("Node '");
+    title << ref->name() << B_TRANSLATE("' created");
     logMsg.AddString("title", title);
 
     // create a default group for the node
@@ -210 +216 @@
 
     // prepare the log message
     BMessage logMsg(M_LOG);
-    BString title = "Node '";
-    title << ref->name() << "' released";
+    BString title = B_TRANSLATE("Node '");
+    title << ref->name() << B_TRANSLATE("' released");
     logMsg.AddString("title", title);
 
     if(ref->kind() & B_TIME_SOURCE) {
@@ -234 +240 @@
 
     // prepare the log message
     BMessage logMsg(M_LOG);
-    BString title = "Connection ";
+    BString title = B_TRANSLATE("Connection ");
     if (strcmp(connection->outputName(), connection->inputName()) == 0) {
         title << "'" << connection->outputName() << "' ";
     }
-    title << "made";
+    title << B_TRANSLATE("made");
     logMsg.AddString("title", title);
 
     if(!(connection->flags() & Connection::INTERNAL))
@@ -265 +271 @@
     }
 
     // add node names to log messages
-    BString line = "Between:";
+    BString line = B_TRANSLATE("Between:");
     logMsg.AddString("line", line);
     line = "    ";
-    line << producer->name() << " and ";
+    line << producer->name() << B_TRANSLATE(" and ");
     line << consumer->name();
     logMsg.AddString("line", line);
 
     // add format to log message
-    line = "Negotiated format:";
+    line = B_TRANSLATE("Negotiated format:");
     logMsg.AddString("line", line);
     line = "    ";
     line << MediaString::getStringFor(connection->format(), false);
     logMsg.AddString("line", line);
 
     NodeGroup *group = 0;
-    BString groupName = "Untitled group ";
+    BString groupName = B_TRANSLATE("Untitled group ");
     if(_canGroup(producer) && _canGroup(consumer))
     {
         if (producer->group() && consumer->group() &&
@@ -335 +341 @@
         
     // prepare the log message
     BMessage logMsg(M_LOG);
-    BString title = "Connection ";
+    BString title = B_TRANSLATE("Connection ");
     if (strcmp(connection->outputName(), connection->inputName()) == 0) {
         title << "'" << connection->outputName() << "' ";
     }
-    title << "broken";
+    title << B_TRANSLATE("broken");
     logMsg.AddString("title", title);
 
     if(!(connection->flags() & Connection::INTERNAL))
@@ -371 +377 @@
     }
 
     // add node names to log messages
-    BString line = "Between:";
+    BString line = B_TRANSLATE("Between:");
     logMsg.AddString("line", line);
     line = "    ";
-    line << producer->name() << " and ";
+    line << producer->name() << B_TRANSLATE(" and ");
     line << consumer->name();
     logMsg.AddString("line", line);
     
@@ -402 +408 @@
         
     // prepare the log message
     BMessage logMsg(M_LOG);
-    BString title = "Connection failed";
+    BString title = B_TRANSLATE("Connection failed");
     logMsg.AddString("title", title);
     logMsg.AddInt32("error", error);
 
@@ -417 +423 @@
     }
 
     // add node names to log messages
-    BString line = "Between:";
+    BString line = B_TRANSLATE("Between:");
     logMsg.AddString("line", line);
     line = "    ";
     line << producer->name() << " and " << consumer->name();
     logMsg.AddString("line", line);
 
     // add format to log message
-    line = "Tried format:";
+    line = B_TRANSLATE("Tried format:");
     logMsg.AddString("line", line);
     line = "    ";
     line << MediaString::getStringFor(format, true);

src/apps/cortex/RouteApp/RouteWindow.cpp

@@ -64 +64 @@
 #define D_HOOK(x) //PRINT (x)
 #define D_INTERNAL(x) //PRINT (x)
 
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexRouteApp"
+
 __USE_CORTEX_NAMESPACE
 
 
-const char* const RouteWindow::s_windowName = "Cortex";
+const char* const RouteWindow::s_windowName = B_TRANSLATE("Cortex");
 
 const BRect RouteWindow::s_initFrame(100,100,700,550);
 
 const char* const g_aboutText =
-    "Cortex/Route 2.1.2\n\n"
+    B_TRANSLATE("Cortex/Route 2.1.2\n\n"
     "Copyright 1999-2000 Eric Moon\n"
     "All rights reserved.\n\n"
     "The Cortex Team:\n\n"
@@ -80 +86 @@
     "Eric Moon: UI, back-end\n\n"
     "Thanks to:\nJohn Ashmun\nJon Watte\nDoug Wright\n<your name here>\n\n"
     "Certain icons used herein are the property of\n"
-    "Be, Inc. and are used by permission.";
+    "Be, Inc. and are used by permission.");
 
 
 RouteWindow::~RouteWindow()
@@ -103 +109 @@
 
     // initialize the menu bar: add all menus that target this window
     BMenuBar* pMenuBar = new BMenuBar(b, "menuBar");
-    BMenu* pFileMenu = new BMenu("File");
-    BMenuItem* item = new BMenuItem("Open" B_UTF8_ELLIPSIS,
+    BMenu* pFileMenu = new BMenu(B_TRANSLATE("File"));
+    BMenuItem* item = new BMenuItem(B_TRANSLATE("Open" B_UTF8_ELLIPSIS),
         new BMessage(RouteApp::M_SHOW_OPEN_PANEL), 'O');
     item->SetTarget(be_app);
     pFileMenu->AddItem(item);
     pFileMenu->AddItem(new BSeparatorItem());
-    item = new BMenuItem("Save nodes" B_UTF8_ELLIPSIS,
+    item = new BMenuItem(B_TRANSLATE("Save nodes" B_UTF8_ELLIPSIS),
         new BMessage(RouteApp::M_SHOW_SAVE_PANEL), 'S');
     item->SetTarget(be_app);
     pFileMenu->AddItem(item);
     pFileMenu->AddItem(new BSeparatorItem());
-    pFileMenu->AddItem(new BMenuItem("About Cortex/Route" B_UTF8_ELLIPSIS,
+    pFileMenu->AddItem(new BMenuItem(B_TRANSLATE("About Cortex/Route" B_UTF8_ELLIPSIS),
         new BMessage(B_ABOUT_REQUESTED)));
     pFileMenu->AddItem(new BSeparatorItem());
-    pFileMenu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED)));
+    pFileMenu->AddItem(new BMenuItem(B_TRANSLATE("Quit"), new BMessage(B_QUIT_REQUESTED)));
     pMenuBar->AddItem(pFileMenu);
     AddChild(pMenuBar);
 
@@ -166 +172 @@
     SetSizeLimits(minWidth, maxWidth, minHeight, maxHeight);
 
     // construct the Window menu
-    BMenu* windowMenu = new BMenu("Window");
+    BMenu* windowMenu = new BMenu(B_TRANSLATE("Window"));
     m_transportWindowItem = new BMenuItem(
-        "Show transport",
+        B_TRANSLATE("Show transport"),
         new BMessage(M_TOGGLE_TRANSPORT_WINDOW));
     windowMenu->AddItem(m_transportWindowItem);
 
     m_dormantNodeWindowItem = new BMenuItem(
-        "Show add-ons",
+        B_TRANSLATE("Show add-ons"),
         new BMessage(M_TOGGLE_DORMANT_NODE_WINDOW));
     windowMenu->AddItem(m_dormantNodeWindowItem);
 
     windowMenu->AddItem(new BSeparatorItem());
 
     m_pullPalettesItem = new BMenuItem(
-        "Pull palettes",
+        B_TRANSLATE("Pull palettes"),
         new BMessage(M_TOGGLE_PULLING_PALETTES));
     windowMenu->AddItem(m_pullPalettesItem);
 
@@ -373 +379 @@
     switch (pMsg->what) {
         case B_ABOUT_REQUESTED:
         {
-            BAlert* alert = new BAlert("About", g_aboutText, "OK");
+            BAlert* alert = new BAlert("About", g_aboutText, B_TRANSLATE("OK"));
             alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
             alert->Go();
             break;

src/apps/cortex/TipManager/Jamfile

@@ -12 +12 @@
     TipManagerImpl.cpp
     TipWindow.cpp
     TipView.cpp
+    : $(HAIKU_LOCALE_LIBS)
+;
+
+DoCatalogs Cortex :
+    application/x-vnd.Cortex.Route
+    :
+    TipWindow.cpp
 ;

src/apps/cortex/TipManager/TipWindow.cpp

@@ -35 +35 @@
 #include "TipView.h"
 
 #include <Debug.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexTipManager"
 
 __USE_CORTEX_NAMESPACE
 
@@ -145 +150 @@
     if(m_text.Length())
         m_tipView->setText(m_text.String());
     else
-        m_tipView->setText("(no info)");
+        m_tipView->setText(B_TRANSLATE("(no info)"));
 }
 
 void TipWindow::_destroyTipView() {

src/apps/cortex/TransportView/Jamfile

@@ -14 +14 @@
 StaticLibrary cortex_transport_view.a :
     TransportView.cpp
     TransportWindow.cpp
+    : $(HAIKU_LOCALE_LIBS)  
+;
+
+DoCatalogs Cortex :
+    application/x-vnd.Cortex.Route
+    :
+    TransportView.cpp
 ;

src/apps/cortex/TransportView/TransportView.cpp

@@ -56 +56 @@
 
 #include <algorithm>
 #include <functional>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexTransportView"
 
 using namespace std;
 
@@ -136 +141 @@
         // background +++++
         
         // name
-        BString name = g ? g->name() : "(no group)";
+        BString name = g ? g->name() : B_TRANSLATE("(no group)");
         // +++++ constrain width
         SetFont(&m_boldFont);
         DrawString(name.String(), m_namePosition);
@@ -149 +154 @@
             nodeCount << g->countNodes();
         else
             nodeCount << '0';
-        nodeCount << ((nodeCount == "1") ? " node." : " nodes.");
+        nodeCount << ((nodeCount == "1") ? B_TRANSLATE(" node.") : B_TRANSLATE(" nodes."));
         // +++++ constrain width
         DrawString(nodeCount.String(), m_nodeCountPosition);
         
         // status
-        BString status = "No errors.";
+        BString status = B_TRANSLATE("No errors.");
         // +++++ constrain width
         DrawString(status.String(), m_statusPosition);
     }
@@ -569 +574 @@
 //};
 //const int _time_sources = 2;
 
-const char* _region_start_label = "From:";
-const char* _region_end_label = "To:";
+const char* _region_start_label = B_TRANSLATE("From:");
+const char* _region_end_label = B_TRANSLATE("To:");
 
 void TransportView::_constructControls() {
 
@@ -595 +600 @@
     m_runModeView = new BMenuField(
         BRect(),
         "runModeView",
-        "Run mode:",
+        B_TRANSLATE("Run mode:"),
         new BPopUpMenu("runModeMenu"));
     _populateRunModeMenu(
         m_runModeView->Menu());
@@ -604 +609 @@
     m_timeSourceView = new BMenuField(
         BRect(),
         "timeSourceView",
-        "Time source:",
+        B_TRANSLATE("Time source:"),
         new BPopUpMenu("timeSourceMenu"));
     _populateTimeSourceMenu(
         m_timeSourceView->Menu());
     AddChild(m_timeSourceView);
 
 
-    m_fromLabel = new BStringView(BRect(), 0, "Roll from");
+    m_fromLabel = new BStringView(BRect(), 0, B_TRANSLATE("Roll from"));
     AddChild(m_fromLabel);
     
     
@@ -673 +678 @@
     m_startButton = new BButton(
         BRect(),
         "startButton",
-        "Start",
+        B_TRANSLATE("Start"),
         m);
     _addGroupTarget(m_startButton);
     AddChild(m_startButton);
@@ -682 +687 @@
     m_stopButton = new BButton(
         BRect(),
         "stopButton",
-        "Stop",
+        B_TRANSLATE("Stop"),
         m);
     _addGroupTarget(m_stopButton);
     AddChild(m_stopButton);
@@ -691 +696 @@
     m_prerollButton = new BButton(
         BRect(),
         "prerollButton",
-        "Preroll",
+        B_TRANSLATE("Preroll"),
         m);
     _addGroupTarget(m_prerollButton);
     AddChild(m_prerollButton);
@@ -737 +742 @@
             &dacTimeSource,
             sizeof(media_node));
         i = new BMenuItem(
-            "DAC time source",
+            B_TRANSLATE("DAC time source"),
             m);
         menu->AddItem(i);
         _addGroupTarget(i);
@@ -752 +757 @@
             &systemTimeSource,
             sizeof(media_node));
         i = new BMenuItem(
-            "System clock",
+            B_TRANSLATE("System clock"),
             m);
         menu->AddItem(i);
         _addGroupTarget(i);
@@ -980 +985 @@
         (runMode == BMediaNode::B_OFFLINE ||
             !m_group->canCycle())) {
             
-        m_startButton->SetLabel("Roll");
+        m_startButton->SetLabel(B_TRANSLATE("Roll"));
         m_startButton->Message()->what = NodeGroup::M_ROLL;
 
     } else {
-        m_startButton->SetLabel("Start");
+        m_startButton->SetLabel(B_TRANSLATE("Start"));
         m_startButton->Message()->what = NodeGroup::M_START;
     }
 }
@@ -1005 +1010 @@
     BMenu* menu = m_timeSourceView->Menu();
     ASSERT(menu);
     if(tsNode == media_node::null) {
-        menu->Superitem()->SetLabel("(none)");
+        menu->Superitem()->SetLabel(B_TRANSLATE("(none)"));
         return;
     }
 

src/apps/cortex/addons/AudioAdapter/AudioAdapterParams.cpp

@@ -33 +33 @@
 
 #include "AudioAdapterParams.h"
 
+#include <Catalog.h>
 #include <Debug.h>
 #include <ParameterWeb.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAudioAdapter"
+
 status_t
 _AudioAdapterParams::store(int32 parameterID, const void* data, size_t size)
 {
@@ -110 +114 @@
 void _AudioAdapterParams::populateGroup(
     BParameterGroup*                group) {
     
-    BParameterGroup* inputGroup = group->MakeGroup("Input Format");
+    BParameterGroup* inputGroup = group->MakeGroup(B_TRANSLATE("Input Format"));
     
     BNullParameter* groupName;
     BDiscreteParameter* param;
 
     groupName = inputGroup->MakeNullParameter(
-        0, B_MEDIA_NO_TYPE, "Input Format", B_GENERIC);
+        0, B_MEDIA_NO_TYPE, B_TRANSLATE("Input Format"), B_GENERIC);
 
     param = inputGroup->MakeDiscreteParameter(
         P_INPUT_FORMAT,
         B_MEDIA_NO_TYPE,
-        "Sample format:",
+        B_TRANSLATE("Sample format:"),
         B_GENERIC);
     param->AddItem(
         0,
@@ -142 +146 @@
     param = inputGroup->MakeDiscreteParameter(
         P_INPUT_CHANNEL_COUNT,
         B_MEDIA_NO_TYPE,
-        "Channels:",
+        B_TRANSLATE("Channels:"),
         B_GENERIC);
     param->AddItem(
         0,
@@ -160 +164 @@
         8,
         "8");
 
-    BParameterGroup* outputGroup = group->MakeGroup("Output Format");
+    BParameterGroup* outputGroup = group->MakeGroup(B_TRANSLATE("Output format"));
 
     groupName = outputGroup->MakeNullParameter(
-        0, B_MEDIA_NO_TYPE, "Output Format", B_GENERIC);
+        0, B_MEDIA_NO_TYPE, B_TRANSLATE("Output format"), B_GENERIC);
 
     param = outputGroup->MakeDiscreteParameter(
         P_OUTPUT_FORMAT,
         B_MEDIA_NO_TYPE,
-        "Sample format:",
+        B_TRANSLATE("Sample format:"),
         B_GENERIC);
     param->AddItem(
         0,
@@ -189 +193 @@
     param = outputGroup->MakeDiscreteParameter(
         P_OUTPUT_CHANNEL_COUNT,
         B_MEDIA_NO_TYPE,
-        "Channels:",
+        B_TRANSLATE("Channels:"),
         B_GENERIC);
     param->AddItem(
         0,

src/apps/cortex/addons/AudioAdapter/Jamfile

@@ -21 +21 @@
     RawBuffer.cpp
     SoundUtils.cpp
 
-    : be media $(TARGET_LIBSUPC++)
+    : be media $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/addons/Flanger/FlangerAddOn.cpp

@@ -34 +34 @@
 
 #include "FlangerNode.h"
 #include "FlangerAddOn.h"
+#include <Catalog.h>
 #include <Entry.h>
 #include <Debug.h>
 #include <cstring>
 #include <cstdlib>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsFlanger"
+
 // instantiation function
 extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id image);
 extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id image) {
@@ -76 +80 @@
     
     flavor_info* pInfo = new flavor_info;
     pInfo->internal_id = n;
-    pInfo->name = (char *)"Flanger";
+    pInfo->name = (char *)B_TRANSLATE("Flanger");
     pInfo->info = (char *)
-        "An add-on version of FlangerNode.\n"
-        "by Eric Moon (16 June, 1999)";
+        B_TRANSLATE("An add-on version of FlangerNode.\n"
+        "by Eric Moon (16 June, 1999)");
     pInfo->kinds = B_BUFFER_CONSUMER | B_BUFFER_PRODUCER | B_CONTROLLABLE;
     pInfo->flavor_flags = 0;
     pInfo->possible_count = 0;

src/apps/cortex/addons/Flanger/FlangerNode.cpp

@@ -40 +40 @@
 #include <Buffer.h>
 #include <BufferGroup.h>
 #include <ByteOrder.h>
+#include <Catalog.h>
 #include <Debug.h>
 #include <ParameterWeb.h>
 #include <TimeSource.h>
@@ -49 +50 @@
 #include <cstring>
 #include <cmath>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsFlanger"
+
 // -------------------------------------------------------- //
 // local helpers
 // -------------------------------------------------------- //
@@ -245 +249 @@
     m_input.node = Node();
     m_input.source = media_source::null;
     m_input.format = m_format;
-    strncpy(m_input.name, "Audio Input", B_MEDIA_NAME_LENGTH);
+    strncpy(m_input.name, B_TRANSLATE("Audio input"), B_MEDIA_NAME_LENGTH);
 
     // init output
     m_output.source.port = ControlPort();
@@ -253 +257 @@
     m_output.node = Node();
     m_output.destination = media_destination::null;
     m_output.format = m_format;
-    strncpy(m_output.name, "Mix Output", B_MEDIA_NAME_LENGTH);
+    strncpy(m_output.name, B_TRANSLATE("Mix output"), B_MEDIA_NAME_LENGTH);
 
     // init parameters
     initParameterValues();
@@ -1251 +1255 @@
 // create and register a parameter web
 void FlangerNode::initParameterWeb() {
     BParameterWeb* pWeb = new BParameterWeb();
-    BParameterGroup* pTopGroup = pWeb->MakeGroup("FlangerNode Parameters");
+    BParameterGroup* pTopGroup = pWeb->MakeGroup(B_TRANSLATE("FlangerNode parameters"));
 
     BNullParameter* label;
     BContinuousParameter* value;
     BParameterGroup* g;
 
     // mix ratio
-    g = pTopGroup->MakeGroup("Mix ratio");
+    g = pTopGroup->MakeGroup(B_TRANSLATE("Mix ratio"));
     label = g->MakeNullParameter(
         P_MIX_RATIO_LABEL,
         B_MEDIA_NO_TYPE,
-        "Mix ratio",
+        B_TRANSLATE("Mix ratio"),
         B_GENERIC);
 
     value = g->MakeContinuousParameter(
@@ -1274 +1278 @@
     value->AddInput(label);
 
     // sweep rate
-    g = pTopGroup->MakeGroup("Sweep rate");
+    g = pTopGroup->MakeGroup(B_TRANSLATE("Sweep rate"));
     label = g->MakeNullParameter(
         P_SWEEP_RATE_LABEL,
         B_MEDIA_NO_TYPE,
-        "Sweep rate",
+        B_TRANSLATE("Sweep rate"),
         B_GENERIC);
 
     value = g->MakeContinuousParameter(
@@ -1290 +1294 @@
     value->AddInput(label);
 
     // sweep range: minimum delay
-    g = pTopGroup->MakeGroup("Delay");
+    g = pTopGroup->MakeGroup(B_TRANSLATE("Delay"));
     label = g->MakeNullParameter(
         P_DELAY_LABEL,
         B_MEDIA_NO_TYPE,
-        "Delay",
+        B_TRANSLATE("Delay"),
         B_GENERIC);
 
     value = g->MakeContinuousParameter(
@@ -1306 +1310 @@
     value->AddInput(label);
 
     // sweep range: maximum
-    g = pTopGroup->MakeGroup("Depth");
+    g = pTopGroup->MakeGroup(B_TRANSLATE("Depth"));
     label = g->MakeNullParameter(
         P_DEPTH_LABEL,
         B_MEDIA_NO_TYPE,
-        "Depth",
+        B_TRANSLATE("Depth"),
         B_GENERIC);
 
     value = g->MakeContinuousParameter(
@@ -1322 +1326 @@
     value->AddInput(label);
 
     // feedback
-    g = pTopGroup->MakeGroup("Feedback");
+    g = pTopGroup->MakeGroup(B_TRANSLATE("Feedback"));
     label = g->MakeNullParameter(
         P_FEEDBACK_LABEL,
         B_MEDIA_NO_TYPE,
-        "Feedback",
+        B_TRANSLATE("Feedback"),
         B_GENERIC);
 
     value = g->MakeContinuousParameter(

src/apps/cortex/addons/Flanger/Jamfile

@@ -10 +10 @@
     MediaNodeControlApp.cpp
     RawBuffer.cpp
     SoundUtils.cpp
-    : be media $(TARGET_LIBSUPC++)
+    : be media $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
     : Resource.rsrc
 ;

src/apps/cortex/addons/LoggingConsumer/Jamfile

@@ -11 +11 @@
     NodeHarnessWin.cpp
     LogWriter.cpp
     LoggingConsumer.cpp
-    : be media
+    : be media $(HAIKU_LOCALE_LIBS)
 ;

src/apps/cortex/addons/LoggingConsumer/LoggingConsumer.cpp

@@ -43 +43 @@
 #include <string.h>
 
 // e.moon [11jun99]
+#include <Catalog.h>
 #include <Debug.h>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsLoggingConsumer"
+
 // id's of the node's BParameters
 const int32 INPUT_NULL_PARAM = 1;
 const int32 LATENCY_PARAM = 2;
@@ -59 +63 @@
 {
     BParameterWeb* web = new BParameterWeb;
 
-    BParameterGroup* mainGroup = web->MakeGroup("LoggingConsumer Parameters");
-    BParameterGroup* group = mainGroup->MakeGroup("Latency control");
-    BParameter* nullParam = group->MakeNullParameter(INPUT_NULL_PARAM, B_MEDIA_NO_TYPE, "Latency", B_GENERIC);
+    BParameterGroup* mainGroup = web->MakeGroup(B_TRANSLATE("LoggingConsumer Parameters"));
+    BParameterGroup* group = mainGroup->MakeGroup(B_TRANSLATE("Latency control"));
+    BParameter* nullParam = group->MakeNullParameter(INPUT_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("Latency"), B_GENERIC);
     BParameter* latencyParam = group->MakeContinuousParameter(LATENCY_PARAM, B_MEDIA_NO_TYPE, "",
         B_GAIN, "ms", 5, 100, 5);
     nullParam->AddOutput(latencyParam);
     latencyParam->AddInput(nullParam);
 
-    group = mainGroup->MakeGroup("CPU percentage");
-    nullParam = group->MakeNullParameter(CPU_NULL_PARAM, B_MEDIA_NO_TYPE, "CPU spin percentage", B_GENERIC);
+    group = mainGroup->MakeGroup(B_TRANSLATE("CPU percentage"));
+    nullParam = group->MakeNullParameter(CPU_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("CPU spin percentage"), B_GENERIC);
     BContinuousParameter* cpuParam = group->MakeContinuousParameter(CPU_SPIN_PARAM, B_MEDIA_NO_TYPE, "",
-        B_GAIN, "percent", 5, 80, 5);
+        B_GAIN, B_TRANSLATE("percent"), 5, 80, 5);
     nullParam->AddOutput(cpuParam);
     cpuParam->AddInput(nullParam);
 
-    group = mainGroup->MakeGroup("Priority");
-    nullParam = group->MakeNullParameter(PRIO_NULL_PARAM, B_MEDIA_NO_TYPE, "Thread priority", B_GENERIC);
+    group = mainGroup->MakeGroup(B_TRANSLATE("Priority"));
+    nullParam = group->MakeNullParameter(PRIO_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("Thread priority"), B_GENERIC);
     BDiscreteParameter* prioParam = group->MakeDiscreteParameter(PRIORITY_PARAM, B_MEDIA_NO_TYPE, "", B_GENERIC);
     prioParam->AddItem(5, "B_LOW_PRIORITY");
     prioParam->AddItem(10, "B_NORMAL_PRIORITY");
@@ -521 +525 @@
     mInput.destination.port = ControlPort();
     mInput.destination.id = 0;
     mInput.node = Node();
-    strcpy(mInput.name, "Logged input");
+    strcpy(mInput.name, B_TRANSLATE("Logged input"));
 }
 
 void

src/apps/cortex/addons/LoggingConsumer/LoggingConsumerAddOn.cpp

@@ -37 +37 @@
 #include "LoggingConsumerAddOn.h"
 #include <Entry.h>
 #include <Debug.h>
+#include <Catalog.h>
 #include <cstring>
 #include <cstdlib>
 
 // logfile path
 const char* const       g_pLogPath = "/tmp/node_log";
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsLoggingConsumer"
 
 // instantiation function
 extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id image) {
@@ -80 +83 @@
 
     flavor_info* pInfo = new flavor_info;
     pInfo->internal_id = n;
-    pInfo->name = "LoggingConsumer";
+    pInfo->name = B_TRANSLATE("LoggingConsumer");
     pInfo->info =
-        "An add-on version of the LoggingConsumer node.\n"
+        B_TRANSLATE("An add-on version of the LoggingConsumer node.\n"
         "See the Be Developer Newsletter III.18: 5 May, 1999\n"
-        "adapted by Eric Moon (4 June, 1999)";
+        "adapted by Eric Moon (4 June, 1999)");
     pInfo->kinds = B_BUFFER_CONSUMER | B_CONTROLLABLE;
     pInfo->flavor_flags = 0;
     pInfo->possible_count = 0;

src/apps/cortex/addons/LoggingConsumer/NodeHarnessApp.cpp

@@ -35 +35 @@
 #include "NodeHarnessApp.h"
 #include "NodeHarnessWin.h"
 
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsLoggingConsumers"
+
 NodeHarnessApp::NodeHarnessApp(const char *signature)
     : BApplication(signature)
 {
@@ -43 +48 @@
 void
 NodeHarnessApp::ReadyToRun()
 {
-    BWindow* win = new NodeHarnessWin(BRect(100, 200, 210, 330), "NodeLogger");
+    BWindow* win = new NodeHarnessWin(BRect(100, 200, 210, 330), B_TRANSLATE("NodeLogger"));
     win->Show();
 }

src/apps/cortex/addons/LoggingConsumer/NodeHarnessWin.cpp

@@ -44 +44 @@
 #include <media/MediaTheme.h>
 #include <stdio.h>
 
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsLoggingConsumer"
+
 const int32 BUTTON_CONNECT = 'Cnct';
 const int32 BUTTON_START = 'Strt';
 const int32 BUTTON_STOP = 'Stop';
@@ -69 +74 @@
 {
     // build the UI
     BRect r(10, 10, 100, 40);
-    mConnectButton = new BButton(r, "Connect", "Connect", new BMessage(BUTTON_CONNECT));
+    mConnectButton = new BButton(r, "Connect", B_TRANSLATE("Connect"), new BMessage(BUTTON_CONNECT));
     mConnectButton->SetEnabled(true);
     AddChild(mConnectButton);
     r.OffsetBy(0, 40);
-    mStartButton = new BButton(r, "Start", "Start", new BMessage(BUTTON_START));
+    mStartButton = new BButton(r, "Start", B_TRANSLATE("Start"), new BMessage(BUTTON_START));
     mStartButton->SetEnabled(false);
     AddChild(mStartButton);
     r.OffsetBy(0, 40);
-    mStopButton = new BButton(r, "Stop", "Stop", new BMessage(BUTTON_STOP));
+    mStopButton = new BButton(r, "Stop", B_TRANSLATE("Stop"), new BMessage(BUTTON_STOP));
     mStopButton->SetEnabled(false);
     AddChild(mStopButton);
 }
@@ -159 +164 @@
             BParameterWeb* web;
             r->GetParameterWebFor(mConnection.consumer, &web);
             BView* view = BMediaTheme::ViewFor(web);
-            BWindow* win = new BWindow(BRect(250, 200, 300, 300), "Controls",
+            BWindow* win = new BWindow(BRect(250, 200, 300, 300), B_TRANSLATE("Controls"),
                 B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS);
             win->AddChild(view);
             win->ResizeTo(view->Bounds().Width(), view->Bounds().Height());

src/apps/cortex/addons/NullFilter/NullFilterAddOn.cpp

@@ -38 +38 @@
 
 #include <Entry.h>
 #include <Debug.h>
+#include <Catalog.h>
 #include <cstring>
 #include <cstdlib>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsNullFilter"
+
 // -------------------------------------------------------- //
 // _NullFilterNode
 // -------------------------------------------------------- //
@@ -119 +123 @@
     
     flavor_info* pInfo = new flavor_info;
     pInfo->internal_id = n;
-    pInfo->name = "NullFilter";
+    pInfo->name = B_TRANSLATE("NullFilter");
     pInfo->info =
-        "NullFilter (empty test filter).\n"
-        "by Eric Moon (8 September 1999)";
+        B_TRANSLATE("NullFilter (empty test filter).\n"
+        "by Eric Moon (8 September 1999)");
     pInfo->kinds = B_BUFFER_CONSUMER | B_BUFFER_PRODUCER | B_CONTROLLABLE;
     pInfo->flavor_flags = 0;
     pInfo->possible_count = 0;
@@ -163 +167 @@
 }
 
 
-// END -- NullFilterAddOn.cpp --
- No newline at end of file
+// END -- NullFilterAddOn.cpp --

src/apps/cortex/addons/ToneProducer/NodeHarnessApp.cpp

@@ -33 +33 @@
 #include "NodeHarnessApp.h"
 #include "NodeHarnessWin.h"
 
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsToneProducer"
+
 NodeHarnessApp::NodeHarnessApp(const char *signature)
     : BApplication(signature)
 {
@@ -41 +46 @@
 void
 NodeHarnessApp::ReadyToRun()
 {
-    BWindow* win = new NodeHarnessWin(BRect(100, 200, 210, 330), "ToneProducer");
+    BWindow* win = new NodeHarnessWin(BRect(100, 200, 210, 330), B_TRANSLATE("ToneProducer"));
     win->Show();
 }

src/apps/cortex/addons/ToneProducer/NodeHarnessWin.cpp

@@ -41 +41 @@
 #include <media/MediaTheme.h>
 #include <stdio.h>
 
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsToneProducer"
+
 const int32 BUTTON_CONNECT = 'Cnct';
 const int32 BUTTON_START = 'Strt';
 const int32 BUTTON_STOP = 'Stop';
@@ -66 +71 @@
 {
     // build the UI
     BRect r(10, 10, 100, 40);
-    mConnectButton = new BButton(r, "Connect", "Connect", new BMessage(BUTTON_CONNECT));
+    mConnectButton = new BButton(r, "Connect", B_TRANSLATE("Connect"), new BMessage(BUTTON_CONNECT));
     mConnectButton->SetEnabled(true);
     AddChild(mConnectButton);
     r.OffsetBy(0, 40);
-    mStartButton = new BButton(r, "Start", "Start", new BMessage(BUTTON_START));
+    mStartButton = new BButton(r, "Start", B_TRANSLATE("Start"), new BMessage(BUTTON_START));
     mStartButton->SetEnabled(false);
     AddChild(mStartButton);
     r.OffsetBy(0, 40);
-    mStopButton = new BButton(r, "Stop", "Stop", new BMessage(BUTTON_STOP));
+    mStopButton = new BButton(r, "Stop", B_TRANSLATE("Stop"), new BMessage(BUTTON_STOP));
     mStopButton->SetEnabled(false);
     AddChild(mStopButton);
 

src/apps/cortex/addons/ToneProducer/ToneProducer.cpp

@@ -49 +49 @@
 #include <math.h>
 
 #include <Messenger.h>
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsToneProducer"
 
 #include <Debug.h>
 #if DEBUG
@@ -118 +122 @@
     mOutput.source.port = ControlPort();
     mOutput.source.id = 0;
     mOutput.node = Node();
-    ::strcpy(mOutput.name, "ToneProducer Output");
+    ::strcpy(mOutput.name, B_TRANSLATE("ToneProducer output"));
 }
 
 ToneProducer::~ToneProducer()
@@ -1063 +1067 @@
     FPRINTF(stderr, "make_parameter_web() called\n");
 
     BParameterWeb* web = new BParameterWeb;
-    BParameterGroup* mainGroup = web->MakeGroup("Tone Generator Parameters");
+    BParameterGroup* mainGroup = web->MakeGroup(B_TRANSLATE("Tone generator parameters"));
 
-    BParameterGroup* group = mainGroup->MakeGroup("Frequency");
-    BParameter* nullParam = group->MakeNullParameter(FREQUENCY_NULL_PARAM, B_MEDIA_NO_TYPE, "Frequency", B_GENERIC);
+    BParameterGroup* group = mainGroup->MakeGroup(B_TRANSLATE("Frequency"));
+    BParameter* nullParam = group->MakeNullParameter(FREQUENCY_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("Frequency"), B_GENERIC);
     BContinuousParameter* param = group->MakeContinuousParameter(FREQUENCY_PARAM, B_MEDIA_NO_TYPE, "", B_GAIN, "Hz", 0, 2500, 0.1);
     nullParam->AddOutput(param);
     param->AddInput(nullParam);
 
-    group = mainGroup->MakeGroup("Amplitude");
-    nullParam = group->MakeNullParameter(GAIN_NULL_PARAM, B_MEDIA_NO_TYPE, "Amplitude", B_GENERIC);
+    group = mainGroup->MakeGroup(B_TRANSLATE("Amplitude"));
+    nullParam = group->MakeNullParameter(GAIN_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("Amplitude"), B_GENERIC);
     param = group->MakeContinuousParameter(GAIN_PARAM, B_MEDIA_NO_TYPE, "", B_GAIN, "", 0, 1, 0.01);
     nullParam->AddOutput(param);
     param->AddInput(nullParam);
 
-    group = mainGroup->MakeGroup("Waveform");
-    nullParam = group->MakeNullParameter(WAVEFORM_NULL_PARAM, B_MEDIA_NO_TYPE, "Waveform", B_GENERIC);
+    group = mainGroup->MakeGroup(B_TRANSLATE("Waveform"));
+    nullParam = group->MakeNullParameter(WAVEFORM_NULL_PARAM, B_MEDIA_NO_TYPE, B_TRANSLATE("Waveform"), B_GENERIC);
     BDiscreteParameter* waveParam = group->MakeDiscreteParameter(WAVEFORM_PARAM, B_MEDIA_NO_TYPE, "", B_GENERIC);
-    waveParam->AddItem(SINE_WAVE, "Sine wave");
-    waveParam->AddItem(TRIANGLE_WAVE, "Triangle");
-    waveParam->AddItem(SAWTOOTH_WAVE, "Sawtooth");
+    waveParam->AddItem(SINE_WAVE, B_TRANSLATE("Sine wave"));
+    waveParam->AddItem(TRIANGLE_WAVE, B_TRANSLATE"Triangle"));
+    waveParam->AddItem(SAWTOOTH_WAVE, B_TRANSLATE("Sawtooth"));
     nullParam->AddOutput(waveParam);
     waveParam->AddInput(nullParam);
 

src/apps/cortex/addons/ToneProducer/ToneProducerAddOn.cpp

@@ -38 +38 @@
 #include <cstring>
 #include <cstdlib>
 
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsToneProducer"
+
 // instantiation function
 extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id image) {
     return new ToneProducerAddOn(image);
@@ -72 +77 @@
 
     flavor_info* pInfo = new flavor_info;
     pInfo->internal_id = n;
-    pInfo->name = "ToneProducer";
+    pInfo->name = B_TRANSLATE("ToneProducer");
     pInfo->info =
-        "An add-on version of the ToneProducer node.\n"
+        B_TRANSLATE("An add-on version of the ToneProducer node.\n"
         "See the Be Developer Newsletter: 2 June, 1999\n"
-        "adapted by Eric Moon (4 June, 1999)";
+        "adapted by Eric Moon (4 June, 1999)");
     pInfo->kinds = B_BUFFER_PRODUCER | B_CONTROLLABLE;
     pInfo->flavor_flags = 0;
     pInfo->possible_count = 0;

src/apps/cortex/addons/common/AudioFilterNode.cpp

@@ -42 +42 @@
 #include <Buffer.h>
 #include <BufferGroup.h>
 #include <ByteOrder.h>
+#include <Catalog.h>
 #include <ParameterWeb.h>
 #include <String.h>
 #include <TimeSource.h>
@@ -52 +53 @@
 #include <cstring>
 //#include <cmath>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsCommon"
+
 // -------------------------------------------------------- //
 // constants 
 // -------------------------------------------------------- //
@@ -398 +402 @@
     err = getRequiredInputFormat(m_input.format);
     ASSERT(err == B_OK);
 
-    strncpy(m_input.name, "Audio Input", B_MEDIA_NAME_LENGTH);
+    strncpy(m_input.name, B_TRANSLATE("Audio input"), B_MEDIA_NAME_LENGTH);
     
     // init output
     m_output.source.port = ControlPort();
@@ -410 +414 @@
     err = getRequiredOutputFormat(m_output.format);
     ASSERT(err == B_OK);
 
-    strncpy(m_output.name, "Audio Output", B_MEDIA_NAME_LENGTH);
+    strncpy(m_output.name, B_TRANSLATE("Audio output"), B_MEDIA_NAME_LENGTH);
 
     // init parameters
     initParameterWeb();
@@ -1324 +1328 @@
     
     BParameterWeb* web = new BParameterWeb();
     BString groupName = Name();
-    groupName << " Parameters";
+    groupName << B_TRANSLATE(" parameters");
     BParameterGroup* group = web->MakeGroup(groupName.String());
     m_parameterSet->populateGroup(group);
     

src/apps/cortex/addons/common/MediaNodeControlApp.cpp

@@ -40 +40 @@
 #include <ParameterWeb.h>
 #include <String.h>
 #include <Alert.h>
+#include <Catalog.h>
 
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexAddOnsCommon"
+
 // -------------------------------------------------------- //
 // ctor/dtor
 // -------------------------------------------------------- //
@@ -82 +86 @@
     if(err < B_OK) {
         char buffer[512];
         sprintf(buffer,
-            "MediaNodeControlApp: couldn't find node (%ld):\n%s\n",
+            B_TRANSLATE("MediaNodeControlApp: couldn't find node (%ld):\n%s\n"),
             nodeID, strerror(err));
-        BAlert* alert = new BAlert("error", buffer, "OK");
+        BAlert* alert = new BAlert("error", buffer, B_TRANSLATE("OK"));
         alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
         alert->Go();
         return;
@@ -96 +100 @@
     if(err < B_OK) {
         char buffer[512];
         sprintf(buffer,
-            "MediaNodeControlApp: couldn't get node info (%ld):\n%s\n",
+            B_TRANSLATE("MediaNodeControlApp: couldn't get node info (%ld):\n%s\n"),
             nodeID, strerror(err));
-        BAlert* alert = new BAlert("error", buffer, "OK");
+        BAlert* alert = new BAlert("error", buffer, B_TRANSLATE("OK"));
         alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
         alert->Go();
         return;
     }
     
     BString windowTitle;
-    windowTitle << nInfo.name << '(' << nodeID << ") controls";     
+    windowTitle << nInfo.name << '(' << nodeID << ") " << B_TRANSLATE("controls");      
     
     // get parameter web
     BParameterWeb* pWeb;
@@ -113 +117 @@
     if(err < B_OK) {
         char buffer[512];
         sprintf(buffer,
-            "MediaNodeControlApp: no parameters for node (%ld):\n%s\n",
+            B_TRANSLATE("MediaNodeControlApp: no parameters for node (%ld):\n%s\n"),
             nodeID, strerror(err));
-        BAlert* alert = new BAlert("error", buffer, "OK");
+        BAlert* alert = new BAlert("error", buffer, B_TRANSLATE("OK"));
         alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
         alert->Go();
         return;

src/apps/cortex/support/Jamfile

@@ -17 +17 @@
     observe.cpp
     SoundUtils.cpp
     TextControlFloater.cpp
+    : $(HAIKU_LOCALE_LIBS)
+;
+
+DoCatalogs Cortex :
+    application/x-vnd.Cortex.Route
+    :
+    MediaString.cpp
 ;

src/apps/cortex/support/MediaString.cpp

@@ -37 +37 @@
 #include <MediaFormats.h>
 // Support Kit
 #include <String.h>
+// Locale Kit
+#include <Catalog.h>
+
+#undef B_TRANSLATION_CONTEXT
+#define B_TRANSLATION_CONTEXT "CortexMediaString"
 
 __USE_CORTEX_NAMESPACE
 
@@ -57 +62 @@
 
     if (kinds & B_BUFFER_PRODUCER) {
         if (first) {
-            list = "Buffer producer";
+            list = B_TRANSLATE("Buffer producer");
             first = false;
         }
     }
     if (kinds & B_BUFFER_CONSUMER) {
         if (first) {
-            list = "Buffer consumer";
+            list = B_TRANSLATE("Buffer consumer");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Buffer consumer";
+            last = B_TRANSLATE("Buffer consumer");
         }
     }
     if (kinds & B_TIME_SOURCE) {
         if (first) {
-            list = "Time source";
+            list = B_TRANSLATE("Time source");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Time source";
+            last = B_TRANSLATE("Time source");
         }
     }
     if (kinds & B_CONTROLLABLE) {
         if (first) {
-            list = "Controllable";
+            list = B_TRANSLATE("Controllable");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Controllable";
+            last = B_TRANSLATE("Controllable");
         }
     }
     if (kinds & B_FILE_INTERFACE) {
         if (first) {
-            list = "File interface";
+            list = B_TRANSLATE("File interface");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "File interface";
+            last = B_TRANSLATE("File interface");
         }
     }
     if (kinds & B_ENTITY_INTERFACE) {
         if (first) {
-            list = "Entity interface";
+            list = B_TRANSLATE("Entity interface");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Entity interface";
+            last = B_TRANSLATE("Entity interface");
         }
     }
     if (kinds & B_PHYSICAL_INPUT) {
         if (first) {
-            list = "Physical input";
+            list = B_TRANSLATE("Physical input");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Physical input";
+            last = B_TRANSLATE("Physical input");
         }
     }
     if (kinds & B_PHYSICAL_OUTPUT) {
         if (first) {
-            list = "Physical output";
+            list = B_TRANSLATE("Physical output");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Physical output";
+            last = B_TRANSLATE("Physical output");
         }
     }
     if (kinds & B_SYSTEM_MIXER) {
         if (first) {
-            list = "System mixer";
+            list = B_TRANSLATE("System mixer");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "System mixer";
+            last = B_TRANSLATE("System mixer");
         }
     }
 
@@ -162 +167 @@
     D_METHOD(("MediaString::getStringFor(run_mode)\n"));
 
     switch (runMode) {
-        case BMediaNode::B_OFFLINE:             return "Offline";
-        case BMediaNode::B_RECORDING:           return "Recording";
-        case BMediaNode::B_DECREASE_PRECISION:  return "Decrease precision";
-        case BMediaNode::B_INCREASE_LATENCY:    return "Increase latency";
-        case BMediaNode::B_DROP_DATA:           return "Drop data";
-        default:                                return "(unknown run mode)";
+        case BMediaNode::B_OFFLINE:             return B_TRANSLATE("Offline");
+        case BMediaNode::B_RECORDING:           return B_TRANSLATE("Recording");
+        case BMediaNode::B_DECREASE_PRECISION:  return B_TRANSLATE("Decrease precision");
+        case BMediaNode::B_INCREASE_LATENCY:    return B_TRANSLATE("Increase latency");
+        case BMediaNode::B_DROP_DATA:           return B_TRANSLATE("Drop data");
+        default:                                return B_TRANSLATE("(unknown run mode)");
     }
 }
 
@@ -181 +186 @@
     D_METHOD(("MediaString::getStringFor(media_type)\n"));
 
     switch (type) {
-        case B_MEDIA_NO_TYPE:           return "Typeless media";
-        case B_MEDIA_UNKNOWN_TYPE:      return "Unknown media type";
-        case B_MEDIA_RAW_AUDIO:         return "Raw audio";
-        case B_MEDIA_RAW_VIDEO:         return "Raw video";
-        case B_MEDIA_VBL:               return "Raw data from VBL area";
-        case B_MEDIA_TIMECODE:          return "Timecode";
-        case B_MEDIA_MIDI:              return "MIDI";
-        case B_MEDIA_TEXT:              return "Text";
-        case B_MEDIA_HTML:              return "HTML";
-        case B_MEDIA_MULTISTREAM:       return "Multistream media";
-        case B_MEDIA_PARAMETERS:        return "Parameters";
-        case B_MEDIA_ENCODED_AUDIO:     return "Encoded audio";
-        case B_MEDIA_ENCODED_VIDEO:     return "Encoded video";
+        case B_MEDIA_NO_TYPE:           return B_TRANSLATE("Typeless media");
+        case B_MEDIA_UNKNOWN_TYPE:      return B_TRANSLATE("Unknown media type");
+        case B_MEDIA_RAW_AUDIO:         return B_TRANSLATE("Raw audio");
+        case B_MEDIA_RAW_VIDEO:         return B_TRANSLATE("Raw video");
+        case B_MEDIA_VBL:               return B_TRANSLATE("Raw data from VBL area");
+        case B_MEDIA_TIMECODE:          return B_TRANSLATE("Timecode");
+        case B_MEDIA_MIDI:              return B_TRANSLATE("MIDI");
+        case B_MEDIA_TEXT:              return B_TRANSLATE("Text");
+        case B_MEDIA_HTML:              return B_TRANSLATE("HTML");
+        case B_MEDIA_MULTISTREAM:       return B_TRANSLATE("Multistream media");
+        case B_MEDIA_PARAMETERS:        return B_TRANSLATE("Parameters");
+        case B_MEDIA_ENCODED_AUDIO:     return B_TRANSLATE("Encoded audio");
+        case B_MEDIA_ENCODED_VIDEO:     return B_TRANSLATE("Encoded video");
         default: {
             if (type >= B_MEDIA_FIRST_USER_TYPE)
-                return "User-defined media type";
+                return B_TRANSLATE("User-defined media type");
             if (type >= B_MEDIA_PRIVATE)
-                return "Private Be media type";
+                return B_TRANSLATE("Private Be media type");
         }
     }
-    return "Unknown Media Type";
+    return B_TRANSLATE("Unknown media type");
 }
 
 BString MediaString::getStringFor(
@@ -210 +215 @@
     D_METHOD(("MediaString::getStringFor(media_format_family)\n"));
 
     switch (family) {
-        case B_ANY_FORMAT_FAMILY:       return "Any format family";
-        case B_BEOS_FORMAT_FAMILY:      return "BeOS format family";
-        case B_QUICKTIME_FORMAT_FAMILY: return "QuickTime format family";
-        case B_AVI_FORMAT_FAMILY:       return "AVI format family";
-        case B_ASF_FORMAT_FAMILY:       return "ASF format family";
-        case B_MPEG_FORMAT_FAMILY:      return "MPEG format family";
-        case B_WAV_FORMAT_FAMILY:       return "WAV format family";
-        case B_AIFF_FORMAT_FAMILY:      return "AIFF format family";
-        default:                        return "Miscellaneous format family";
+        case B_ANY_FORMAT_FAMILY:       return B_TRANSLATE("Any format family");
+        case B_BEOS_FORMAT_FAMILY:      return B_TRANSLATE("BeOS format family");
+        case B_QUICKTIME_FORMAT_FAMILY: return B_TRANSLATE("QuickTime format family");
+        case B_AVI_FORMAT_FAMILY:       return B_TRANSLATE("AVI format family");
+        case B_ASF_FORMAT_FAMILY:       return B_TRANSLATE("ASF format family");
+        case B_MPEG_FORMAT_FAMILY:      return B_TRANSLATE("MPEG format family");
+        case B_WAV_FORMAT_FAMILY:       return B_TRANSLATE("WAV format family");
+        case B_AIFF_FORMAT_FAMILY:      return B_TRANSLATE("AIFF format family");
+        default:                        return B_TRANSLATE("Miscellaneous format family");
     }
 }
 
@@ -488 +493 @@
     BString s;
     if ((source.port != media_source::null.port)
      && (source.id != media_source::null.id)) {
-        s << "Port " << source.port << ", ID " << source.id;
+        s << B_TRANSLATE("Port ") << source.port << B_TRANSLATE(", ID ") << source.id;
     }
     else {
-        s = "(none)";
+        s = B_TRANSLATE("(none)");
     }
     return s;
 }
@@ -504 +509 @@
     BString s;
     if ((destination.port != media_destination::null.port)
      && (destination.id != media_destination::null.id)) {
-        s << "Port " << destination.port << ", ID " << destination.id;
+        s << B_TRANSLATE("Port ") << destination.port << B_TRANSLATE(", ID ") << destination.id;
     }
     else {
-        s = "(none)";
+        s = B_TRANSLATE("(none)");
     }
     return s;
 }
@@ -528 +533 @@
 
     switch (format) {
         case media_raw_audio_format::B_AUDIO_UCHAR: {
-            return "8 bit integer";
+            return B_TRANSLATE("8 bit integer");
         }
         case media_raw_audio_format::B_AUDIO_SHORT: {
-            return "16 bit integer";
+            return B_TRANSLATE("16 bit integer");
         }
         case media_raw_audio_format::B_AUDIO_FLOAT: {
-            return "32 bit float";
+            return B_TRANSLATE("32 bit float");
         }
         case media_raw_audio_format::B_AUDIO_INT: {
             BString s = "";
             if (validBits != media_multi_audio_format::wildcard.valid_bits)
-                s << validBits << " bit ";
+                s << validBits << B_TRANSLATE(" bit ");
             else
-                s << "32 bit ";
-            s << "integer";
+                s << B_TRANSLATE("32 bit ");
+            s << B_TRANSLATE("integer");
             return s;
         }
         default: {
-            return "(unknown format)";
+            return B_TRANSLATE("(unknown format)");
         }
     }
 }
@@ -576 +581 @@
     
     switch (channelCount) {
         case 1: {
-            return "Mono";
+            return B_TRANSLATE("Mono");
         }
         case 2: {
-            return "Stereo";
+            return B_TRANSLATE("Stereo");
         }
         default: {
             BString s = "";
-            s << channelCount << " Channels";
+            s << channelCount << B_TRANSLATE(" channels");
             return s;
         }   
     }
@@ -600 +605 @@
 
     switch (byteOrder) {
         case B_MEDIA_BIG_ENDIAN: {
-            return "Big endian";
+            return B_TRANSLATE("Big endian");
         }
         case B_MEDIA_LITTLE_ENDIAN: {
-            return "Little endian";
+            return B_TRANSLATE("Little endian");
         }
         default: {
-            return "(unknown byte order)";
+            return B_TRANSLATE("(unknown byte order)");
         }
     }
 }
@@ -621 +626 @@
     }
 
     BString s = "";
-    s << bufferSize << " bytes per buffer";
+    s << bufferSize << B_TRANSLATE(" bytes per buffer");
     return s;
 }
 
@@ -634 +639 @@
 
     if (channelMask & B_CHANNEL_LEFT) {
         if (first) {
-            list = "Left";
+            list = B_TRANSLATE("Left");
             first = false;
         }
     }
     if (channelMask & B_CHANNEL_RIGHT) {
         if (first) {
-            list = "Right";
+            list = B_TRANSLATE("Right");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Right";
+            last = B_TRANSLATE("Right");
         }
     }
     if (channelMask & B_CHANNEL_CENTER) {
         if (first) {
-            list = "Center";
+            list = B_TRANSLATE("Center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Center";
+            last = B_TRANSLATE("Center");
         }
     }
     if (channelMask & B_CHANNEL_SUB) {
         if (first) {
-            list = "Sub";
+            list = B_TRANSLATE("Sub");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Sub";
+            last = B_TRANSLATE("Sub");
         }
     }
     if (channelMask & B_CHANNEL_REARLEFT) {
         if (first) {
-            list = "Rear-left";
+            list = B_TRANSLATE("Rear-left");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Rear-left";
+            last = B_TRANSLATE("Rear-left");
         }
     }
     if (channelMask & B_CHANNEL_REARRIGHT) {
         if (first) {
-            list = "Rear-right";
+            list = B_TRANSLATE("Rear-right");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Rear-right";
+            last = B_TRANSLATE("Rear-right");
         }
     }
     if (channelMask & B_CHANNEL_FRONT_LEFT_CENTER) {
         if (first) {
-            list = "Front-left-center";
+            list = B_TRANSLATE("Front-left-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Front-left-center";
+            last = B_TRANSLATE("Front-left-center");
         }
     }
     if (channelMask & B_CHANNEL_FRONT_RIGHT_CENTER) {
         if (first) {
-            list = "Front-right-center";
+            list = B_TRANSLATE("Front-right-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Front-right-center";
+            last = B_TRANSLATE("Front-right-center");
         }
     }
     if (channelMask & B_CHANNEL_BACK_CENTER) {
         if (first) {
-            list = "Back-center";
+            list = B_TRANSLATE("Back-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Back-center";
+            last = B_TRANSLATE("Back-center");
         }
     }
     if (channelMask & B_CHANNEL_SIDE_LEFT) {
         if (first) {
-            list = "Side-left";
+            list = B_TRANSLATE("Side-left");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Side-left";
+            last = B_TRANSLATE("Side-left");
         }
     }
     if (channelMask & B_CHANNEL_SIDE_RIGHT) {
         if (first) {
-            list = "Side-right";
+            list = B_TRANSLATE("Side-right");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Side-right";
+            last = B_TRANSLATE("Side-right");
         }
     }
     if (channelMask & B_CHANNEL_TOP_CENTER) {
         if (first) {
-            list = "Top-center";
+            list = B_TRANSLATE("Top-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-center";
+            last = B_TRANSLATE("Top-center");
         }
     }
     if (channelMask & B_CHANNEL_TOP_FRONT_LEFT) {
         if (first) {
-            list = "Top-Front-left";
+            list = B_TRANSLATE("Top-Front-left");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Front-left";
+            last = B_TRANSLATE("Top-Front-left");
         }
     }
     if (channelMask & B_CHANNEL_TOP_FRONT_CENTER) {
         if (first) {
-            list = "Top-Front-center";
+            list = B_TRANSLATE("Top-Front-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Front-center";
+            last = B_TRANSLATE("Top-Front-center");
         }
     }
     if (channelMask & B_CHANNEL_TOP_FRONT_RIGHT) {
         if (first) {
-            list = "Top-Front-right";
+            list = B_TRANSLATE("Top-Front-right");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Front-right";
+            last = B_TRANSLATE("Top-Front-right");
         }
     }
     if (channelMask & B_CHANNEL_TOP_BACK_LEFT) {
         if (first) {
-            list = "Top-Back-left";
+            list = B_TRANSLATE("Top-Back-left");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Back-left";
+            last = B_TRANSLATE("Top-Back-left");
         }
     }
     if (channelMask & B_CHANNEL_TOP_BACK_CENTER) {
         if (first) {
-            list = "Top-Back-center";
+            list = B_TRANSLATE("Top-Back-center");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Back-center";
+            last = B_TRANSLATE("Top-Back-center");
         }
     }
     if (channelMask & B_CHANNEL_TOP_BACK_RIGHT) {
         if (first) {
-            list = "Top-Back-right";
+            list = B_TRANSLATE("Top-Back-right");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Top-Back-right";
+            last = B_TRANSLATE("Top-Back-right");
         }
     }
     if (last != "") {
         list << " & " << last;
     }
     if (list == "") {
-        list = "(none)";
+        list = B_TRANSLATE("(none)");
     }
 
     return list;
@@ -840 +845 @@
     D_METHOD(("MediaString::forAudioMatrixMask()\n"));
 
     switch (matrixMask) {
-        case 0:                                 return "(none)";
-        case B_MATRIX_PROLOGIC_LR:              return "ProLogic LR";
-        case B_MATRIX_AMBISONIC_WXYZ:           return "Ambisonic WXYZ";
-        default:                                return "(unknown matrix mask)";
+        case 0:                                 return B_TRANSLATE("(none)");
+        case B_MATRIX_PROLOGIC_LR:              return B_TRANSLATE("ProLogic LR");
+        case B_MATRIX_AMBISONIC_WXYZ:           return B_TRANSLATE("Ambisonic WXYZ");
+        default:                                return B_TRANSLATE("(unknown matrix mask)");
     }
 }
 
@@ -876 +881 @@
     }
 
     BString s = "";
-    s << frameSize << " bytes per frame";
+    s << frameSize << B_TRANSLATE(" bytes per frame");
     return s;
 }
 
@@ -907 +912 @@
         case B_RGB15_BIG:       return "15 bit RGB";
         case B_RGBA15:
         case B_RGBA15_BIG:      return "15 bit RGBA";
-        case B_CMAP8:           return "8 bit color-index";
-        case B_GRAY8:           return "8 bit grayscale-index";
-        case B_GRAY1:           return "Monochrome";
+        case B_CMAP8:           return B_TRANSLATE("8 bit color-index");
+        case B_GRAY8:           return B_TRANSLATE("8 bit grayscale-index");
+        case B_GRAY1:           return B_TRANSLATE("Monochrome");
         case B_YUV422:          return "YUV422";
         case B_YUV411:          return "YUV411";
         case B_YUV420:          return "YUV420";
@@ -940 +945 @@
         case B_CMYA32:          return "32 bit CMYA";
         case B_CMYK32:          return "32 bit CMYK";
         default: {
-            return "(unknown video format)";
+            return B_TRANSLATE("(unknown video format)");
         }
     }
 }
@@ -973 +978 @@
 
     BString s = "";
     if (interlace == 1) {
-        s << "Non-interlaced ";
+        s << B_TRANSLATE("Non-interlaced ");
     }
     else {
-        s << "Interlaced ";
+        s << B_TRANSLATE("Interlaced ");
     }
     s << fieldRate << " Hz";
     if ((fieldRate > 49.9) && (fieldRate < 50.1)) {
@@ -1001 +1006 @@
 
     switch (orientation) {
         case B_VIDEO_TOP_LEFT_RIGHT: {
-            return "Top to bottom, left to right";
+            return B_TRANSLATE("Top to bottom, left to right");
         }
         case B_VIDEO_BOTTOM_LEFT_RIGHT: {
-            return "Bottom to top, left to right";
+            return B_TRANSLATE("Bottom to top, left to right");
         }
         default: {
-            return "(unkown video orientation)";
+            return B_TRANSLATE("(unkown video orientation)");
         }
     }
 }
@@ -1040 +1045 @@
         return "*";
     }
 
-    BString s = "Video data between";
-    s << " line " << firstActive;
-    s << " and " << lastActive;
+    BString s = B_TRANSLATE("Video data between");
+    s << B_TRANSLATE(" line ") << firstActive;
+    s << B_TRANSLATE(" and ") << lastActive;
     return s;
 }
 
@@ -1056 +1061 @@
     }
 
     BString s = "";
-    s << bytesPerRow << " bytes per row";
+    s << bytesPerRow << B_TRANSLATE(" bytes per row");
     return s;
 }
 
@@ -1068 +1073 @@
 
     BString s = "";
     if (pixelOffset != media_video_display_info::wildcard.pixel_offset) {
-        s << pixelOffset << " pixels";
+        s << pixelOffset << B_TRANSLATE(" pixels");
     }
     if (lineOffset != media_video_display_info::wildcard.line_offset) {
         if (s != "") {
             s << ", ";
         }
-        s << pixelOffset << " lines";
+        s << pixelOffset << B_TRANSLATE(" lines");
     }
     if (s == "") {
         s = "*";
@@ -1095 +1100 @@
 
     BString s = "";
     if (avgBitRate != media_encoded_video_format::wildcard.avg_bit_rate) {
-        s << avgBitRate / 1000.0f << " kb/s (avg)";
+        s << avgBitRate / 1000.0f << B_TRANSLATE(" kb/s (avg)");
     }
     if (maxBitRate != media_encoded_video_format::wildcard.max_bit_rate) {
         if (s != "") {
             s << ", ";
         }
-        s << maxBitRate / 1000.0f << " kb/s (max)";
+        s << maxBitRate / 1000.0f << B_TRANSLATE(" kb/s (max)");
     }
     if (s == "") {
         s = "*";
@@ -1119 +1124 @@
     }
 
     BString s = "";
-    s << frameSize << " bytes per frame";
+    s << frameSize << B_TRANSLATE(" bytes per frame");
     return s;
 }
 
@@ -1131 +1136 @@
 
     BString s = "";
     if (forwardHistory != media_encoded_video_format::wildcard.forward_history) {
-        s << static_cast<int32>(forwardHistory) << " frames forward";
+        s << static_cast<int32>(forwardHistory) << B_TRANSLATE(" frames forward");
     }
     if (backwardHistory != media_encoded_video_format::wildcard.backward_history) {
         if (s != "") {
             s << ", ";
         }
-        s << static_cast<int32>(backwardHistory) << " frames backward";
+        s << static_cast<int32>(backwardHistory) << B_TRANSLATE(" frames backward");
     }
     if (s == "") {
         s = "*";
@@ -1160 +1165 @@
     }
 
     switch (format) {
-        case media_multistream_format::B_VID:       return "BeOS video";
+        case media_multistream_format::B_VID:       return B_TRANSLATE("BeOS video");
         case media_multistream_format::B_AVI:       return "AVI";
         case media_multistream_format::B_MPEG1:     return "MPEG1";
         case media_multistream_format::B_MPEG2:     return "MPEG2";
         case media_multistream_format::B_QUICKTIME: return "QuickTime";
-        default:                                    return "(unknown multistream format)";
+        default:                                    return B_TRANSLATE("(unknown multistream format)");
     }
 }
 
@@ -1177 +1182 @@
 
     BString s = "";
     if (avgBitRate != media_multistream_format::wildcard.avg_bit_rate) {
-        s << avgBitRate / 1000.0f << " kb/s (avg)";
+        s << avgBitRate / 1000.0f << B_TRANSLATE(" kb/s (avg)");
     }
     if (maxBitRate != media_multistream_format::wildcard.max_bit_rate) {
         if (s != "") {
             s << ", ";
         }
-        s << maxBitRate / 1000.0f << " kb/s (max)";
+        s << maxBitRate / 1000.0f << B_TRANSLATE(" kb/s (max)");
     }
     if (s == "") {
         s = "*";
@@ -1199 +1204 @@
 
     BString s = "";
     if (avgChunkSize != media_multistream_format::wildcard.avg_chunk_size) {
-        s << avgChunkSize << " bytes (avg)";
+        s << avgChunkSize << B_TRANSLATE(" bytes (avg)");
     }
     if (maxChunkSize != media_multistream_format::wildcard.max_chunk_size) {
         if (s != "") {
             s << ", ";
         }
-        s << maxChunkSize << " bytes (max)";
+        s << maxChunkSize << B_TRANSLATE(" bytes (max)");
     }
     if (s == "") {
         s = "*";
@@ -1223 +1228 @@
 
     if (flags & media_multistream_format::B_HEADER_HAS_FLAGS) {
         if (first) {
-            list = "Header has flags";
+            list = B_TRANSLATE("Header has flags");
             first = false;
         }
     }
     if (flags & media_multistream_format::B_CLEAN_BUFFERS) {
         if (first) {
-            list = "Clean buffers";
+            list = B_TRANSLATE("Clean buffers");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Clean buffers";
+            last = B_TRANSLATE("Clean buffers");
         }
     }
     if (flags & media_multistream_format::B_HOMOGENOUS_BUFFERS) {
         if (first) {
-            list = "Homogenous buffers";
+            list = B_TRANSLATE("Homogenous buffers");
             first = false;
         }
         else {
             if (last != "")
                 list << ", " << last;
-            last = "Homogenous buffers";
+            last = B_TRANSLATE("Homogenous buffers");
         }
     }
 
@@ -1254 +1259 @@
         list << " & " << last;
 
     if (list == "")
-        list = "(none)";
+        list = B_TRANSLATE("(none)");
 
     return list;
 }