translator_vi.h

Go to the documentation of this file.

/******************************************************************************
 *
 *
 *
 * Copyright (C) 1997-2015 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby
 * granted. No representations are made about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 */

#ifndef TRANSLATOR_VI_H
#define TRANSLATOR_VI_H

/*
 * 17 Oct 2008 : Translation to Vietnamese by
 *               Đặng Minh Tuấn <tuanvietkey@gmail.com>
 *
 */


class TranslatorVietnamese : public TranslatorAdapter_1_6_0
{
  public:

    // --- Language control methods -------------------

    virtual QCString idLanguage()
    { return "vietnamese"; }

    virtual QCString latexLanguageSupportCommand()
    {
      return "";
    }

    // --- Language translation methods -------------------

    virtual QCString trRelatedFunctions()
    { return "Những hàm liên quan"; }

    virtual QCString trRelatedSubscript()
    { return "(Chú ý những hàm này không phải là hàm thành viên.)"; }

    virtual QCString trDetailedDescription()
    { return "Mô tả chi tiết"; }

    virtual QCString trMemberTypedefDocumentation()
    { return "Thông tin về Member Typedef"; }

    virtual QCString trMemberEnumerationDocumentation()
    { return "Thông tin về Member Enumeration"; }

    virtual QCString trMemberFunctionDocumentation()
    { return "Thông tin về hàm thành viên"; }

    virtual QCString trMemberDataDocumentation()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Thông tin về trường";
      }
      else
      {
        return "Thông tin về Member Data";
      }
    }

    virtual QCString trMore()
    { return "Tiếp..."; }

    virtual QCString trListOfAllMembers()
    { return "Liệt kê tất cả các thành viên"; }

    virtual QCString trMemberList()
    { return "Danh sách thành viên"; }

    virtual QCString trThisIsTheListOfAllMembers()
    { return "Danh sách các thành viên đầy đủ cho "; }

    virtual QCString trIncludingInheritedMembers()
    { return ", cùng với tất cả các thành viên kế thừa."; }

    virtual QCString trGeneratedAutomatically(const char *s)
    { QCString result="Được tạo ra bởi Doxygen";
      if (s) result+=(QCString)" cho "+s;
      result+=" từ mã nguồn.";
      return result;
    }

    virtual QCString trEnumName()
    { return "tên enum"; }

    virtual QCString trEnumValue()
    { return "giá trị enum"; }

    virtual QCString trDefinedIn()
    { return "được định nghĩa trong"; }

    // quick reference sections

    virtual QCString trModules()
    { return "Các Modules"; }

    virtual QCString trClassHierarchy()
    { return "Kiến trúc Class"; }

    virtual QCString trCompoundList()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Cấu trúc cơ sở dữ liệu (Data Structures)";
      }
      else
      {
        return "Danh mục các Class";
      }
    }

    virtual QCString trFileList()
    { return "Danh mục File"; }

    virtual QCString trCompoundMembers()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Các trường dữ liệu";
      }
      else
      {
        return "Các thành viên của Class";
      }
    }

    virtual QCString trFileMembers()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Toàn cục";
      }
      else
      {
        return "File thành viên";
      }
    }

    virtual QCString trRelatedPages()
    { return "Các trang liên quan"; }

    virtual QCString trExamples()
    { return "Các ví dụ"; }

    virtual QCString trSearch()
    { return "Tìm kiếm"; }

    virtual QCString trClassHierarchyDescription()
    { return "Danh sách kế thừa đã được sắp xếp theo ABC, "
             "nhưng chưa đầy đủ:";
    }

    virtual QCString trFileListDescription(bool extractAll)
    {
      QCString result="Danh mục đầy đủ tất cả các ";
      if (!extractAll) result+="(đã được biên soạn) ";
      result+="files cùng với các mô tả tóm tắt:";
      return result;
    }

    virtual QCString trCompoundListDescription()
    {

      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Đây là cấu trúc cơ sở dữ liệu với mô tả tóm tắt:";
      }
      else
      {
        return "Đây là các classes, structs, "
               "unions và interfaces với các mô tả tóm tắt:";
      }
    }

    virtual QCString trCompoundMembersDescription(bool extractAll)
    {
      QCString result="Danh mục tất cả các ";
      if (!extractAll)
      {
        result+="(đã được mô tả) ";
      }
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        result+="struct và union fields";
      }
      else
      {
        result+="class members";
      }
      result+=" cùng với các các liên kết đến ";
      if (!extractAll)
      {
        if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
        {
          result+="Thông tin về struct/union cho từng trường:";
        }
        else
        {
          result+="Thông tin về class cho từng thành viên:";
        }
      }
      else
      {
        if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
        {
          result+="các structures/unions thuộc:";
        }
        else
        {
          result+="các lớp thuộc:";
        }
      }
      return result;
    }

    virtual QCString trFileMembersDescription(bool extractAll)
    {
      QCString result="Danh sách tất cả các ";
      if (!extractAll) result+="(đã được mô tat) ";

      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        result+="functions, variables, defines, enums, và typedefs";
      }
      else
      {
        result+="các file thành viên";
      }
      result+=" cùng với links tới ";
      if (extractAll)
        result+="các files thuộc:";
      else
        result+="tài liệu:";
      return result;
    }

    virtual QCString trExamplesDescription()
    { return "Danh sách tất cả các ví dụ:"; }

    virtual QCString trRelatedPagesDescription()
    { return "Danh sách tất cả các trang Thông tin có liên quan:"; }

    virtual QCString trModulesDescription()
    { return "Danh sách tất cả các thành viên:"; }

    // index titles (the project name is prepended for these)

    virtual QCString trDocumentation()
    { return "Thông tin"; }

    virtual QCString trModuleIndex()
    { return "Chỉ mục (Index) Module"; }

    virtual QCString trHierarchicalIndex()
    { return "Hierarchical Index"; }

    virtual QCString trCompoundIndex()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Index cấu trúc cơ sở dữ liệu";
      }
      else
      {
        return "Class Index";
      }
    }

    virtual QCString trFileIndex()
    { return "File Index"; }

    virtual QCString trModuleDocumentation()
    { return "Thông tin về các Module"; }

    virtual QCString trClassDocumentation()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Thông tin về cấu trúc cơ sở dữ liệu";
      }
      else
      {
        return "Thông tin về Class";
      }
    }

    virtual QCString trFileDocumentation()
    { return "Thông tin về File"; }

    virtual QCString trExampleDocumentation()
    { return "Thông tin về các ví dụ"; }

    virtual QCString trPageDocumentation()
    { return "Trang Thông tin"; }

    virtual QCString trReferenceManual()
    { return "Thông tin tham chiếu"; }

    virtual QCString trDefines()
    { return "Định nghĩa"; }

    virtual QCString trTypedefs()
    { return "Typedefs"; }

    virtual QCString trEnumerations()
    { return "Enumerations"; }

    virtual QCString trFunctions()
    { return "Các hàm"; }

    virtual QCString trVariables()
    { return "Các biến"; }

    virtual QCString trEnumerationValues()
    { return "Enumerator"; }

    virtual QCString trDefineDocumentation()
    { return "Thông tin về định nghĩa"; }

    virtual QCString trTypedefDocumentation()
    { return "Thông tin về Typedef"; }

    virtual QCString trEnumerationTypeDocumentation()
    { return "Thông tin về Enumeration Type"; }

    virtual QCString trFunctionDocumentation()
    { return "Thông tin về hàm"; }

    virtual QCString trVariableDocumentation()
    { return "Thông tin về các biến"; }

    virtual QCString trCompounds()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Cấu trúc cơ sở dữ liệu";
      }
      else
      {
        return "Classes";
      }
    }

    virtual QCString trGeneratedAt(const char *date,const char *projName)
    {
      QCString result=(QCString)"Được biên soạn vào "+date;
      if (projName) result+=(QCString)" cho mã nguồn dự án "+projName;
      result+=(QCString)" bởi";
      return result;
    }

    virtual QCString trClassDiagram(const char *clName)
    {
      return (QCString)"Sơ đồ kế thừa cho "+clName+":";
    }

    virtual QCString trForInternalUseOnly()
    { return "Chỉ cho sử dụng nội bộ."; }

    virtual QCString trWarning()
    { return "Lưu ý"; }

    virtual QCString trVersion()
    { return "Phiên bản"; }

    virtual QCString trDate()
    { return "Ngày"; }

    virtual QCString trReturns()
    { return "Giá trị trả về"; }

    virtual QCString trSeeAlso()
    { return "Xem thêm"; }

    virtual QCString trParameters()
    { return "Các tham số"; }

    virtual QCString trExceptions()
    { return "Exceptions"; }

    virtual QCString trGeneratedBy()
    { return "Được biên soạn bởi"; }

// new since 0.49-990307

    virtual QCString trNamespaceList()
    { return "Danh sách Namespace"; }

    virtual QCString trNamespaceListDescription(bool extractAll)
    {
      QCString result="Danh sách tất cả các ";
      if (!extractAll) result+="(đã được biên tập) ";
      result+="namespaces với mô tả tóm tắt:";
      return result;
    }

    virtual QCString trFriends()
    { return "Friends"; }

// new since 0.49-990405

    virtual QCString trRelatedFunctionDocumentation()
    { return "Thông tin về Friends và các hàm liên quan"; }

// new since 0.49-990425

    virtual QCString trCompoundReference(const char *clName,
                                    ClassDef::CompoundType compType,
                                    bool isTemplate)
    {
      QCString result=(QCString)clName;
      switch(compType)
      {
        case ClassDef::Class:      result+=" Class"; break;
        case ClassDef::Struct:     result+=" Struct"; break;
        case ClassDef::Union:      result+=" Union"; break;
        case ClassDef::Interface:  result+=" Interface"; break;
        case ClassDef::Protocol:   result+=" Protocol"; break;
        case ClassDef::Category:   result+=" Category"; break;
        case ClassDef::Exception:  result+=" Exception"; break;
        default: break;
      }
      if (isTemplate) result+=" Template";
      result+=" Tham chiếu";
      return result;
    }

    virtual QCString trFileReference(const char *fileName)
    {
      QCString result=fileName;
      result+=" File Tham chiếu";
      return result;
    }

    virtual QCString trNamespaceReference(const char *namespaceName)
    {
      QCString result=namespaceName;
      result+=" Namespace Tham chiếu";
      return result;
    }

    virtual QCString trPublicMembers()
    { return "Các hàm thành viên Public"; }
    virtual QCString trPublicSlots()
    { return "Public Slots"; }
    virtual QCString trSignals()
    { return "Signals"; }
    virtual QCString trStaticPublicMembers()
    { return "Các hàm Static Public"; }
    virtual QCString trProtectedMembers()
    { return "Các hàm thành viên Protected"; }
    virtual QCString trProtectedSlots()
    { return "Protected Slots"; }
    virtual QCString trStaticProtectedMembers()
    { return "Các hàm thành viên Static Protected"; }
    virtual QCString trPrivateMembers()
    { return "Các hàm thành viên Private"; }
    virtual QCString trPrivateSlots()
    { return "Private Slots"; }
    virtual QCString trStaticPrivateMembers()
    { return "Các hàm thành viên Static Private"; }

    virtual QCString trWriteList(int numEntries)
    {
      QCString result;
      int i;
      // the inherits list contain `numEntries' classes
      for (i=0;i<numEntries;i++)
      {
        // use generateMarker to generate placeholders for the class links!
        result+=generateMarker(i); // generate marker for entry i in the list
                                   // (order is left to right)

        if (i!=numEntries-1)  // not the last entry, so we need a separator
        {
          if (i<numEntries-2) // not the fore last entry
            result+=", ";
          else                // the fore last entry
            result+=", và ";
        }
      }
      return result;
    }

    virtual QCString trInheritsList(int numEntries)
    {
      return "Kế thừa "+trWriteList(numEntries)+".";
    }

    virtual QCString trInheritedByList(int numEntries)
    {
      return "Được kế thừa bởi "+trWriteList(numEntries)+".";
    }

    virtual QCString trReimplementedFromList(int numEntries)
    {
      return "Được thực thi lại từ "+trWriteList(numEntries)+".";
    }

    virtual QCString trReimplementedInList(int numEntries)
    {
      return "Được thực thi lại trong "+trWriteList(numEntries)+".";
    }

    virtual QCString trNamespaceMembers()
    { return "Thành viên Namespace"; }

    virtual QCString trNamespaceMemberDescription(bool extractAll)
    {
      QCString result="Danh sách tất cả các ";
      if (!extractAll) result+="(đã được biên soạn) ";
      result+="các thành viên namespace cùng với link tới ";
      if (extractAll)
        result+="Thông tin namespace cho từng thành viên:";
      else
        result+=" namespaces mà phụ thuộc bởi:";
      return result;
    }
    virtual QCString trNamespaceIndex()
    { return "Namespace Index"; }

    virtual QCString trNamespaceDocumentation()
    { return "Thông tin về Namespace"; }

// new since 0.49-990522

    virtual QCString trNamespaces()
    { return "Namespaces"; }

// new since 0.49-990728

    virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,bool)
    { // here s is one of " Class", " Struct" or " Union"
      // single is true implies a single file
      QCString result=(QCString)"Thông tin cho ";
      switch(compType)
      {
        case ClassDef::Class:      result+="class"; break;
        case ClassDef::Struct:     result+="struct"; break;
        case ClassDef::Union:      result+="union"; break;
        case ClassDef::Interface:  result+="interface"; break;
        case ClassDef::Protocol:   result+="protocol"; break;
        case ClassDef::Category:   result+="category"; break;
        case ClassDef::Exception:  result+="exception"; break;
        default: break;
      }
      result+=" được biên soạn từ các file sau đây";
      result+=":";
      return result;
    }

// new since 0.49-990901

    virtual QCString trReturnValues()
    { return "Các giá trị trả về"; }

    virtual QCString trMainPage()
    { return "Tranh chính"; }

    virtual QCString trPageAbbreviation()
    { return "tr."; }

// new since 0.49-991003

    virtual QCString trDefinedAtLineInSourceFile()
    {
      return "Định nghĩa tại dòng @0 trong file @1.";
    }
    virtual QCString trDefinedInSourceFile()
    {
      return "Định nghĩa trong file @0.";
    }

// new since 0.49-991205

    virtual QCString trDeprecated()
    {
      return "Không tán thành";
    }

// new since 1.0.0

    virtual QCString trCollaborationDiagram(const char *clName)
    {
      return (QCString)"Sơ đồ liên kết cho "+clName+":";
    }
    virtual QCString trInclDepGraph(const char *fName)
    {
      return (QCString)"Kèm theo graph phụ thuộc cho "+fName+":";
    }
    virtual QCString trConstructorDocumentation()
    {
      return "Thông tin về Constructor và Destructor";
    }
    virtual QCString trGotoSourceCode()
    {
      return "Tới mã nguồn của file này.";
    }
    virtual QCString trGotoDocumentation()
    {
      return "Tới Thông tin của file này.";
    }
    virtual QCString trPrecondition()
    {
      return "Điều kiện trước";
    }
    virtual QCString trPostcondition()
    {
      return "Điều kiện sau";
    }
    virtual QCString trInvariant()
    {
      return "Bất biến";
    }
    virtual QCString trInitialValue()
    {
      return "Giá trị khởi tạo:";
    }
    virtual QCString trCode()
    {
      return "mã nguồn";
    }
    virtual QCString trGraphicalHierarchy()
    {
      return "Kiến trúc đồ họa của Class";
    }
    virtual QCString trGotoGraphicalHierarchy()
    {
      return "Tới kiến trúc đồ họa của Class";
    }
    virtual QCString trGotoTextualHierarchy()
    {
      return "Tới kiến trúc text của Class";
    }
    virtual QCString trPageIndex()
    {
      return "Chỉ mục trang";
    }

// new since 1.1.0

    virtual QCString trNote()
    {
      return "Ghi chú";
    }
    virtual QCString trPublicTypes()
    {
      return "Public Types";
    }
    virtual QCString trPublicAttribs()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "các trường đữ liệu";
      }
      else
      {
        return "Các thuộc tính Public";
      }
    }
    virtual QCString trStaticPublicAttribs()
    {
      return "Các thuộc tính Static Public";
    }
    virtual QCString trProtectedTypes()
    {
      return "Các kiểu Protected";
    }
    virtual QCString trProtectedAttribs()
    {
      return "các thuộc tính Protected";
    }
    virtual QCString trStaticProtectedAttribs()
    {
      return "Các thuộc tính Static Protected";
    }
    virtual QCString trPrivateTypes()
    {
      return "Các kiểu Private";
    }
    virtual QCString trPrivateAttribs()
    {
      return "Các thuộc tính Private";
    }
    virtual QCString trStaticPrivateAttribs()
    {
      return "Các thuộc tính Static Private";
    }

// new since 1.1.3

    virtual QCString trTodo()
    {
      return "Mục tiêu";
    }
    virtual QCString trTodoList()
    {
      return "Danh sách hàng mục cần thực hiện";
    }

// new since 1.1.4

    virtual QCString trReferencedBy()
    {
      return "Tham chiếu bởi";
    }
    virtual QCString trRemarks()
    {
      return "Ghi chú";
    }
    virtual QCString trAttention()
    {
      return "Chú ý";
    }
    virtual QCString trInclByDepGraph()
    {
      return "Đồ thị này biểu thị những file nào trực tiếp hoặc"
             "không trực tiếp bao gồm file này:";
    }
    virtual QCString trSince()
    {
      return "Từ";
    }

// new since 1.1.5

    virtual QCString trLegendTitle()
    {
      return "Chú giải Graph";
    }
    virtual QCString trLegendDocs()
    {
      return
        "Trang này giải nghĩa các biểu đồ được biên soạn bởi "
        " doxygen.<p>\n"
        "Hãy xem xét các ví dụ sau:\n"
        "\\code\n"
        "/*! Các lướp không thấy được bởi sự cắt ngắn */\n"
        "Lớp không nhìn thấy class { };\n\n"
        "/*! class bị cắt, quan hệ kế thừa bị ẩn */\n"
        "class bị cắt : bị ẩn toàn cục { };\n\n"
        "/* Class không được mô tả với các chú giải doxygen */\n"
        "class không được mô tả { };\n\n"
        "/*! Class được kế thừa sử dụng các kế thừa public */\n"
        "class PublicBase : public Truncated { };\n\n"
        "/*!  template class */\n"
        "template<class T> class Templ { };\n\n"
        "/*! Class được kế thừa sử dụng kế thừa protected */\n"
        "class ProtectedBase { };\n\n"
        "/*! Class được kế thừa sử dụng kế thừa protected private */\n"
        "class PrivateBase { };\n\n"
        "/*! Class được sử dụng bởi các class kế thừa */\n"
        "class được sử dụng { };\n\n"
        "/*! Super class kế thừa một số các class khác */\n"
        "class được kế thừa : public PublicBase,\n"
        "                  protected ProtectedBase,\n"
        "                  private PrivateBase,\n"
        "                  public Undocumented,\n"
        "                  public Templ<int>\n"
        "{\n"
        "  private:\n"
        "    Used *m_usedClass;\n"
        "};\n"
        "\\endcode\n"
        "Kết quả trong biểu đồ sau đây:"
        "<p><center><img alt=\"\" src=\"graph_legend."+getDotImageExtension()+"\"></center>\n"
        "<p>\n"
        "Các hộp trong biểu đồ trên có ý nghĩa như sau:\n"
        "<ul>\n"
        "<li>%Hộp màu xám biểu thị cấu trúc clas cho "
        "biểu đồ được thể hiện.\n"
        "<li>%Hộp có khung mầu đen biểu thị struct hoặc class được mô tả.\n"
        "<li>%Hộp có khung mầu xám biểu thị struct hoặc class chưa được mô tả.\n"
        "<li>%Hộp có khung mầu đỏ biểu thị struct hoặc class được mổ tả "
        "khi mà không phải tất cả các quan hệ kế thừa/containment được biển diễn.. %Biểu đồ bị "
        "cắt nếu nó không nằm trọn trong các biên được cho trước..\n"
        "</ul>\n"
        "Các mũi tên có ý nghĩa như sau::\n"
        "<ul>\n"
        "<li>%Mũi tên mầu xanh đậm biểu thị các quan hệ kế thừa công khai "
        "giữa 2 class.\n"
        "<li>%Mũi tên màu xanh lá cây đậm biểu thị kế thừa được bảo về (protected).\n"
        "<li>%Mũi tên đỏ đậm biểu thị kế thừa dạng private.\n"
        "<li>%Mũi tên màu hồng đứt quảng biểu thị class được sử dụng "
        "bởi class khác. Mũi tên được gán nhãn với các giá trị "
        "mà các calsss hoặc struct được truy cập tới.\n"
        "<li>%Mũi tên vàng đắt quãng được thị quan hệ giữa template instance và "
        "template class được dẫn xuất từ đó. Mũi tên được gán nhãn với "
        "tham số của template.\n"
        "</ul>\n";
    }
    virtual QCString trLegend()
    {
      return "Chú giải";
    }

// new since 1.2.0

    virtual QCString trTest()
    {
      return "Test";
    }
    virtual QCString trTestList()
    {
      return "Danh sách Test";
    }

// new since 1.2.2

    virtual QCString trProperties()
    {
      return "Thuộc tính";
    }
    virtual QCString trPropertyDocumentation()
    {
      return "Thông tin thuộc tính (Property)";
    }

// new since 1.2.4

    virtual QCString trClasses()
    {
      if (Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
      {
        return "Cấu trúc dữ liệu";
      }
      else
      {
        return "Classes";
      }
    }
    virtual QCString trPackage(const char *name)
    {
      return (QCString)"Gói "+name;
    }
    virtual QCString trPackageList()
    {
      return "Danh sách gói";
    }
    virtual QCString trPackageListDescription()
    {
      return "Danh sách các gói cùng với mô tả tóm tắt (khi có thể có):";
    }
    virtual QCString trPackages()
    {
      return "Các gói";
    }
    virtual QCString trDefineValue()
    {
      return "Giá trị:";
    }

// new since 1.2.5

    virtual QCString trBug()
    {
      return "Lỗi";
    }
    virtual QCString trBugList()
    {
      return "Danh sách lỗi";
    }

// new since 1.2.6

    virtual QCString trRTFansicp()
    {
      return "1258";
    }


    virtual QCString trRTFCharSet()
    {
      return "163";
    }

    virtual QCString trRTFGeneralIndex()
    {
      return "Chỉ số";
    }

    virtual QCString trClass(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Class" : "class"));
      if (!singular)  result+="es";
      return result;
    }

    virtual QCString trFile(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "File" : "file"));
      if (!singular)  result+="s";
      return result;
    }

    virtual QCString trNamespace(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Namespace" : "namespace"));
      if (!singular)  result+="s";
      return result;
    }

    virtual QCString trGroup(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Group" : "group"));
      if (!singular)  result+="s";
      return result;
    }

    virtual QCString trPage(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Trang" : "trang"));
      if (!singular)  result+="";
      return result;
    }

    virtual QCString trMember(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Member" : "member"));
      if (!singular)  result+="s";
      return result;
    }

    virtual QCString trGlobal(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Global" : "global"));
      if (!singular)  result+="s";
      return result;
    }

// new since 1.2.7

    virtual QCString trAuthor(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Tác giả" : "tác giả"));
      if (!singular)  result+="";
      return result;
    }

// new since 1.2.11

    virtual QCString trReferences()
    {
      return "Tham chiếu";
    }

// new since 1.2.13

    virtual QCString trImplementedFromList(int numEntries)
    {
      return "Thực hiện "+trWriteList(numEntries)+".";
    }

    virtual QCString trImplementedInList(int numEntries)
    {
      return "Được thực hiện trong "+trWriteList(numEntries)+".";
    }

// new since 1.2.16

    virtual QCString trRTFTableOfContents()
    {
      return "Mục lục";
    }

// new since 1.2.17

    virtual QCString trDeprecatedList()
    {
      return "Danh sách Deprecated";
    }

// new since 1.2.18

    virtual QCString trEvents()
    {
      return "Sự kiện";
    }
    virtual QCString trEventDocumentation()
    {
      return "Thông tin về sự kiện";
    }

// new since 1.3

    virtual QCString trPackageTypes()
    {
      return "Kiểu gói";
    }
    virtual QCString trPackageMembers()
    {
      return "Các hàm Package";
    }
    virtual QCString trStaticPackageMembers()
    {
      return "Các hàm Static Package";
    }
    virtual QCString trPackageAttribs()
    {
      return "Các thuộc tính Package";
    }
    virtual QCString trStaticPackageAttribs()
    {
      return "Các thuộc tính Static Package";
    }

// new since 1.3.1

    virtual QCString trAll()
    {
      return "Tất cả";
    }
    virtual QCString trCallGraph()
    {
      return "Biểu đồ các lời gọi cho hàm này:";
    }

// new since 1.3.3

    virtual QCString trSearchResultsTitle()
    {
      return "Kết quả tìm kiếm";
    }
    virtual QCString trSearchResults(int numDocuments)
    {
      if (numDocuments==0)
      {
        return "Không có tài liệu nào thỏa mãn các truy vấn của bạn.";
      }
      else if (numDocuments==1)
      {
        return "Tìm thấy <b>1</b> tài liệu thỏa mã truy vấn của bạn.";
      }
      else
      {
        return "Tìm thấy tất cả <b>$num</b> tài liệu thỏa mã truy vấn của bạn. "
               "Hiển thị những thỏa mãn tốt nhất trước.";
      }
    }
    virtual QCString trSearchMatches()
    {
      return "Các kết quả thỏa mãn đk:";
    }

// new since 1.3.8

    virtual QCString trSourceFile(QCString& filename)
    {
      return filename + " File nguồn";
    }

// new since 1.3.9

    virtual QCString trDirIndex()
    { return "Cấu trúc thư mục"; }

    virtual QCString trDirDocumentation()
    { return "Thông tin về thư mục"; }

    virtual QCString trDirectories()
    { return "Các thư mục"; }

    virtual QCString trDirDescription()
    { return "Thư mục đã được sắp xếp theo al-pha-bê, "
             "nhưng chưa đầy đủ:";
    }

    virtual QCString trDirReference(const char *dirName)
    { QCString result=dirName; result+=" Tham chiếu thư mục"; return result; }

    virtual QCString trDir(bool first_capital, bool)
    {
      QCString result((first_capital ? "Thư mục" : "thư mục"));
      return result;
    }

// new since 1.4.1

    virtual QCString trOverloadText()
    {
       return "Hàm thành viên dạng overloaded, "
              "được chỉ ra cho việc tra cứu dễ dàng. Nó khác với hàm ở trên"
              "chỉ ở chỗ những tham số nào nó chấp nhận.";
    }

// new since 1.4.6

    virtual QCString trCallerGraph()
    {
      return "Biểu đồ các lời gọi cho hàm này:";
    }

    virtual QCString trEnumerationValueDocumentation()
    { return "Thông tin Enumerator"; }

// new since 1.5.4 (mainly for Fortran)

    virtual QCString trMemberFunctionDocumentationFortran()
    { return "Thông tin về các hàm và các thủ tục thành viên"; }

    virtual QCString trCompoundListFortran()
    { return "Danh sách kiêu dữ liệu"; }

    virtual QCString trCompoundMembersFortran()
    { return "Trường dữ liệu"; }

    virtual QCString trCompoundListDescriptionFortran()
    { return "Kiểu dữ liệu với các mô tả tóm tắt:"; }

    virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
    {
      QCString result="Danh sách tất cả ";
      if (!extractAll)
      {
        result+="(đã được mô tả) ";
      }
      result+="các kiểu dữ liệu thành viên";
      result+=" cùng với liên kết với ";
      if (!extractAll)
      {
         result+="Thông tin cấu trúc dữ liệu cho từng thành viên";
      }
      else
      {
         result+=" các kiểu dữ liệu thuộc:";
      }
      return result;
    }

    virtual QCString trCompoundIndexFortran()
    { return "Chỉ mục kiểu dữ liệu"; }

    virtual QCString trTypeDocumentation()
    { return "Thông tin về kiểu dữ liệu"; }

    virtual QCString trSubprograms()
    { return "Functions/Subroutines"; }

    virtual QCString trSubprogramDocumentation()
    { return "Thông tin về Function/Subroutine"; }

     virtual QCString trDataTypes()
    { return "Kiểu dữ liệu"; }

    virtual QCString trModulesList()
    { return "Danh sách Modules"; }

    virtual QCString trModulesListDescription(bool extractAll)
    {
      QCString result="Danh sách tất cả ";
      if (!extractAll) result+="(đã được mô tả) ";
      result+="các module với mô tả tóm tắt:";
      return result;
    }

    virtual QCString trCompoundReferenceFortran(const char *clName,
                                    ClassDef::CompoundType compType,
                                    bool isTemplate)
    {
      QCString result=(QCString)clName;
      switch(compType)
      {
        case ClassDef::Class:      result+=" Module"; break;
        case ClassDef::Struct:     result+=" Type"; break;
        case ClassDef::Union:      result+=" Union"; break;
        case ClassDef::Interface:  result+=" Interface"; break;
        case ClassDef::Protocol:   result+=" Protocol"; break;
        case ClassDef::Category:   result+=" Category"; break;
        case ClassDef::Exception:  result+=" Exception"; break;
        default: break;
      }
      if (isTemplate) result+=" Template";
      result+=" Tham chiếu";
      return result;
    }
    virtual QCString trModuleReference(const char *namespaceName)
    {
      QCString result=namespaceName;
      result+=" Tham chiếu Module";
      return result;
    }

    virtual QCString trModulesMembers()
    { return "Thành viên Module"; }

    virtual QCString trModulesMemberDescription(bool extractAll)
    {
      QCString result="Danh sách tất cả ";
      if (!extractAll) result+="(đã được mô tả) ";
      result+="các module thành viên cùng với liên kết tới ";
      if (extractAll)
      {
        result+="Thông tin module cho từng thành viên:";
      }
      else
      {
        result+="các module thuộc:";
      }
      return result;
    }

    virtual QCString trModulesIndex()
    { return "Chỉ mục các Module"; }

    virtual QCString trModule(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Module" : "module"));
      if (!singular)  result+="";
      return result;
    }
    virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
        bool single)
    { // here s is one of " Module", " Struct" or " Union"
      // single is true implies a single file
      QCString result=(QCString)"Thông tin cho ";
      switch(compType)
      {
        case ClassDef::Class:      result+="module"; break;
        case ClassDef::Struct:     result+="type"; break;
        case ClassDef::Union:      result+="union"; break;
        case ClassDef::Interface:  result+="interface"; break;
        case ClassDef::Protocol:   result+="protocol"; break;
        case ClassDef::Category:   result+="category"; break;
        case ClassDef::Exception:  result+="exception"; break;
        default: break;
      }
      result+=" được biên soạn từ các file sau đây";
      if (single) result+=":"; else result+="s:";
      return result;
    }
    virtual QCString trType(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Kiểu" : "kiểu"));
      if (!singular)  result+="";
      return result;
    }
    virtual QCString trSubprogram(bool first_capital, bool singular)
    {
      QCString result((first_capital ? "Chương trình con" : "chương trình con"));
      if (!singular)  result+="";
      return result;
    }

    virtual QCString trTypeConstraints()
    {
      return "Ràng buộc của kiểu (Type)";
    }

};

#endif