translator_cn.h

Go to the documentation of this file.

/******************************************************************************
 *
 * 
 *
 * Copyright (C) 1997-2008 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_CN_H
#define TRANSLATOR_CN_H

#define CN_SPC

class TranslatorChinese : public Translator
{
  public:
    virtual QCString idLanguage()
    { return "chinese"; }

    virtual QCString latexLanguageSupportCommand()
    {
      return "";
    }


    virtual QCString idLanguageCharset()
    { return "gb2312"; }

    virtual QCString trRelatedFunctions()
    { return "��غ���"; }

    virtual QCString trRelatedSubscript()
    { return "��ע�⣺��Щ���dz�Ա��������"; }

    virtual QCString trDetailedDescription()
    { return "��ϸ����"; }

    virtual QCString trMemberTypedefDocumentation()
    { return "��Ա���Ͷ����ĵ�"; }

    virtual QCString trMemberEnumerationDocumentation()
    { return "��Աö�������ĵ�"; }

    virtual QCString trMemberFunctionDocumentation()
    { return "��Ա�����ĵ�"; }

    virtual QCString trMemberDataDocumentation()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) 
                        {
                                return "�ֶ��ĵ�"; 
                        }
                        else {
                                return "��Ա�����ĵ�"; 
                        }
                }

    virtual QCString trMore()
    { return "����..."; }

    virtual QCString trListOfAllMembers()
    { return "���г�Ա���б���"; }

    virtual QCString trMemberList()
    { return "��Ա�б�"; }

    virtual QCString trThisIsTheListOfAllMembers()
    { return "��Ա�������б�����Щ��Ա����"CN_SPC; }

    virtual QCString trIncludingInheritedMembers()
    { return "���������м̳ж����ij�Ա"; }

    virtual QCString trGeneratedAutomatically(const char *s)
    {
                        QCString result;
      if (s) result=(QCString)"Ϊ"CN_SPC+s+"��";
      result+="��"CN_SPC"Doyxgen"CN_SPC"ͨ������Դ�����Զ����ɡ�"; 
      return result;
    }

    virtual QCString trEnumName()
    { return "ö������"; }

    virtual QCString trEnumValue()
    { return "ö��ֵ"; }

    virtual QCString trDefinedIn()
    { return "������"CN_SPC; }

                // quick reference sections


    virtual QCString trModules()
    { return "ģ��"; }

                virtual QCString trClassHierarchy()
    { return "��̳й�ϵ"; }

                virtual QCString trCompoundList()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                return "���ݽṹ"; 
                        }
                        else {
                                return "��������б�"; 
                        }
                }

    virtual QCString trFileList()
    { return "�ļ��б�"; }

    virtual QCString trCompoundMembers()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) { 
                                return "�����ֶ�"; 
                        }
                        else {
                                return "������ͳ�Ա"; 
                        }
                }

    virtual QCString trFileMembers()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                return "ȫ�ֶ���"; 
                        } else {
                                return "�ļ���Ա"; 
                        }
                }

    virtual QCString trRelatedPages()
    { return "���ҳ��"; }

    virtual QCString trExamples()
    { return "ʾ��"; }

    virtual QCString trSearch()
    { return "����"; }

    virtual QCString trClassHierarchyDescription()
    { return "���б��������ֵ�˳������"; }

    virtual QCString trFileListDescription(bool extractAll)
    {
                QCString result="���������";
      if (!extractAll) result+="�ĵ�����";
      result+="�ļ���������Ҫ˵����";
      return result;
    }

    virtual QCString trCompoundListDescription()
    { 

                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                        {
                                return "�����г��������ݽṹ��������Ҫ˵����"; 
                        }
                        else
                        {
                                return "�����г������ࡢ�ṹ�������Լ��ӿڶ��壬������Ҫ˵����"; 
                        }
    }

    virtual QCString trCompoundMembersDescription(bool extractAll)
    {
                QCString result="���������";
      if (!extractAll) {
                                result+="�ĵ�����";
                        }
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                result+="�ṹ�����ϵij�Ա������";
                        }
                        else {
                                result+="���Ա������";
                        }

      if (extractAll) {
                                if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                        result+="���ڽṹ�����ϵ��ĵ������ӣ�";
                                }
                                else {
                                        result+="��������ĵ������ӣ�";
                                }
                        }
      else {
                                if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                        result+="�����ṹ�����ϵ����ӣ�";
                                }
                                else {
                                        result+="����������ӣ�";
                                }
                        }
      return result;
    }

    virtual QCString trFileMembersDescription(bool extractAll)
    {
                QCString result="���������";
      if (!extractAll) 
                                result +="�ĵ�����";

                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C")) {
                                result +="�������������꣬ö�ٺ����Ͷ��壬����";
                        } 
                        else {
                                result +="�ļ���Ա������";
                        }

      if (extractAll) 
                                result+="�����ļ����ĵ������ӣ�";
      else 
                                result+="�����ļ������ӣ�";
      return result;
    }

    virtual QCString trExamplesDescription()
    { return "�����г�����ʾ����"; }

    virtual QCString trRelatedPagesDescription()
    { return "�����г�������ص�ҳ�棺"; }

    virtual QCString trModulesDescription()
    { return "�����г�����ģ��"; }

    virtual QCString trDocumentation()
    { return "�ĵ�"; }

    virtual QCString trModuleIndex()
    { return "ģ������"; }

    virtual QCString trHierarchicalIndex()
    { return "�̳й�ϵ����"; }

    virtual QCString trCompoundIndex()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                        {
                                return "���ݽṹ����"; 
                        } 
                        else {
                                return "�����������"; 
                        }
                }

    virtual QCString trFileIndex() 
    { return "�ļ�����"; }

    virtual QCString trModuleDocumentation()
    { return "ģ���ĵ�"; }

    virtual QCString trClassDocumentation()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                        {
                                return "���ݽṹ�ĵ�";
                        }
                        else {
                                return "���ĵ�"; 
                        }
                }

    virtual QCString trFileDocumentation()
    { return "�ļ��ĵ�"; }

    virtual QCString trExampleDocumentation()
    { return "ʾ���ĵ�"; }

    virtual QCString trPageDocumentation()
    { return "ҳ���ĵ�"; }

    virtual QCString trReferenceManual()
    { return "�ο��ֲ�"; }

    virtual QCString trDefines()
    { return "�궨��"; }

    virtual QCString trFuncProtos()
    { return "����ԭ��"; }

    virtual QCString trTypedefs()
    { return "���Ͷ���"; }

    virtual QCString trEnumerations()
    { return "ö��"; }

    virtual QCString trFunctions()
    { return "����"; }

    virtual QCString trVariables()
    { return "����"; }

    virtual QCString trEnumerationValues()
    { return "ö��ֵ"; }


                virtual QCString trDefineDocumentation()
    { return "�궨���ĵ�"; }

                virtual QCString trFunctionPrototypeDocumentation()
    { return "����ԭ���ĵ�"; }

                virtual QCString trTypedefDocumentation()
    { return "���Ͷ����ĵ�"; }

                virtual QCString trEnumerationTypeDocumentation()
    { return "ö�������ĵ�"; }

                virtual QCString trFunctionDocumentation()
    { return "�����ĵ�"; }

                virtual QCString trVariableDocumentation()
    { return "�����ĵ�"; }

                virtual QCString trCompounds()
    { 
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                        { 
                                return "���ݽṹ";
                        }
                        else {
                                return "�������"; 
                        }
                }

                virtual QCString trGeneratedAt(const char *date,const char *projName)
    { 
                QCString result=(QCString)"Generated at "+date;
      if (projName) result+=(QCString)" for "+projName;
      result+=(QCString)" by";
      return result;
    }

                virtual QCString trWrittenBy()
    {
      return "written by";
    }

                virtual QCString trClassDiagram(const char *clName)
    {
      return (QCString)"�̳�ͼ����"CN_SPC+clName;
    }

                virtual QCString trForInternalUseOnly()
    { return "�����ڲ�ʹ�á�"; }

                virtual QCString trWarning()
    { return "����"; }

                virtual QCString trVersion()
    { return "�汾"; }

                virtual QCString trDate()
    { return "����"; }

                virtual QCString trReturns()
    { return "����"; }

                virtual QCString trSeeAlso()
    { return "�μ�"; }

                virtual QCString trParameters()
    { return "����"; }

                virtual QCString trExceptions()
    { return "�쳣"; }

                virtual QCString trGeneratedBy()
    { return "������"; }
    
// new since 0.49-990307 
    
                virtual QCString trNamespaceList()
    { return "���ֿռ��б�"; }

                virtual QCString trNamespaceListDescription(bool extractAll)
    {
                QCString result="���������";
      if (!extractAll) result+="�ĵ�����";
      result+="���ֿռ䶨�壬������Ҫ˵����";
      return result;
    }

                virtual QCString trFriends()
    { return "��Ԫ"; }

// new since 0.49-990405
    
                virtual QCString trRelatedFunctionDocumentation()
    { return "��Ԫ����غ����ĵ�"; }
    
// new since 0.49-990425

                virtual QCString trCompoundReference(const char *clName,
                                 ClassDef::CompoundType compType,
                                 bool isTemplate)
      // used as the title of the HTML page of a class/struct/union
    {
                QCString result=(QCString)clName;
      if (isTemplate) result+=CN_SPC"ģ��";
      switch(compType)
      {
        case ClassDef::Class:  result+="��"; break;
        case ClassDef::Struct: result+="�ṹ"; break;
        case ClassDef::Union:  result+="����"; break;
        case ClassDef::Interface:  result+="�ӿ�"; break;
        case ClassDef::Protocol:   result+="��"; break;
        case ClassDef::Category:   result+="����"; break;
        case ClassDef::Exception:  result+="�쳣"; break;
      }
      result+="�ο�";
      return result;
    }

                virtual QCString trFileReference(const char *fileName)
      // used as the title of the HTML page of a file
    {
                QCString result=fileName;
      result+=CN_SPC"�ļ��ο�"; 
      return result;
    }

                virtual QCString trNamespaceReference(const char *namespaceName)
      // used as the title of the HTML page of a namespace
    {
                QCString result=namespaceName;
      result+=CN_SPC"���ֿռ�ο�";
      return result;
    }
    
    // these are for the member sections of a class, struct or union 
                virtual QCString trPublicMembers()
    { return "���г�Ա"; }

                virtual QCString trPublicSlots()
    { return "���в�"; }

                virtual QCString trSignals()
    { return "�ź�"; }

                virtual QCString trStaticPublicMembers()
    { return "��̬���г�Ա"; }

                virtual QCString trProtectedMembers()
    { return "������Ա"; }

                virtual QCString trProtectedSlots()
    { return "������"; }

                virtual QCString trStaticProtectedMembers()
    { return "��̬������Ա"; }
                
                virtual QCString trPrivateMembers()
    { return "˽�г�Ա"; }
                
                virtual QCString trPrivateSlots()
    { return "˽�в�"; }
                
                virtual QCString trStaticPrivateMembers()
    { return "��̬˽�г�Ա"; }
                
    // end of member sections 
    
                virtual QCString trWriteList(int numEntries)
    {
      // this function is used to produce a comma-separated list of items.
      // use generateMarker(i) to indicate where item i should be put.
                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+=CN_SPC"��"CN_SPC;
        }
      }
      return result; 
    }
    
                virtual QCString trInheritsList(int numEntries)
      // used in class documentation to produce a list of base classes,
      // if class diagrams are disabled.
    {
      return "�̳���"CN_SPC+trWriteList(numEntries)+"��";
    }

                virtual QCString trInheritedByList(int numEntries)
      // used in class documentation to produce a list of super classes,
      // if class diagrams are disabled.
    {
      return "��"CN_SPC+trWriteList(numEntries)+CN_SPC"�̳�.";
    }
                
                virtual QCString trReimplementedFromList(int numEntries)
      // used in member documentation blocks to produce a list of 
      // members that are hidden by this one.
    {
      return "����"CN_SPC+trWriteList(numEntries)+"��";
    }
                
                virtual QCString trReimplementedInList(int numEntries)
    {
      // used in member documentation blocks to produce a list of
      // all member that overwrite the implementation of this member.
      return "��"CN_SPC+trWriteList(numEntries)+CN_SPC"���ء�";
    }

                virtual QCString trNamespaceMembers()
      // This is put above each page as a link to all members of namespaces.
    { return "���ֿռ��Ա"; }
                
                virtual QCString trNamespaceMemberDescription(bool extractAll)
      // This is an introduction to the page with all namespace members
    { 
                QCString result="�����������";
      if (!extractAll) result+="�ĵ�����";
      result+="���ֿռ��Ա������";
      if (extractAll) 
        result+="��������ĵ������ӣ�";
      else 
        result+="����������ӣ�";
      return result;
    }

                virtual QCString trNamespaceIndex()
      // This is used in LaTeX as the title of the chapter with the 
      // index of all namespaces.
    { return "���ֿռ�����"; }

                virtual QCString trNamespaceDocumentation()
      // This is used in LaTeX as the title of the chapter containing
      // the documentation of all namespaces.
    { return "���ֿռ��ĵ�"; }

// new since 0.49-990522

                virtual QCString trNamespaces()
    {
      // return "Namespaces";
      return "���ֿռ�";
    }

// 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)"��";
      switch(compType)
      {
        case ClassDef::Class:      result+="��"; break;
        case ClassDef::Struct:     result+="�ṹ"; break;
        case ClassDef::Union:      result+="����"; break;
        case ClassDef::Interface:  result+="�ӿ�"; break;
        case ClassDef::Protocol:   result+="��"; break;
        case ClassDef::Category:   result+="����"; break;
        case ClassDef::Exception:  result+="�쳣"; break;
      }
      result+="���ĵ��������ļ����ɣ�";
      return result;
    }

                virtual QCString trAlphabeticalList()
    { return "���ֵ�˳��������б�"; }

// new since 0.49-990901

                virtual QCString trReturnValues()
    { return "����ֵ"; }

                virtual QCString trMainPage()
    { return "��ҳ"; }

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

// new since 0.49-991106

                virtual QCString trDefinedAtLineInSourceFile()
    {
      return "���ļ�"CN_SPC"@1"CN_SPC"��"CN_SPC"@0"CN_SPC"�ж��塣";
    }

                virtual QCString trDefinedInSourceFile()
    {
      return "���ļ�"CN_SPC"@0"CN_SPC"�ж��塣";
    }

// new since 0.49-991205

                virtual QCString trDeprecated()
    {
      return "Deprecated";
    }

// new since 1.0.0

                virtual QCString trCollaborationDiagram(const char *clName)
    {
      return (QCString)clName+CN_SPC"����ͼ��";
    }

                virtual QCString trInclDepGraph(const char *fName)
    {
      return (QCString)fName+CN_SPC"����/������ϵͼ��";
    }

                virtual QCString trConstructorDocumentation()
    {
      return "���켰���������ĵ�"; 
    }

                virtual QCString trGotoSourceCode()
    {
      return "������ļ���Դ���롣";
    }

                virtual QCString trGotoDocumentation()
    {
      return "������ļ����ĵ���";
    }

                virtual QCString trPrecondition()
    {
      return "ǰ������";
    }

                virtual QCString trPostcondition()
    {
      return "��������";
    }

                virtual QCString trInvariant()
    {
      return "������";
    }

                virtual QCString trInitialValue()
    {
      return "��ʼ�����У�";
    }

                virtual QCString trCode()
    {
      return "����";
    }

                virtual QCString trGraphicalHierarchy()
    {
      return "��̳й�ϵͼ";
    }

                virtual QCString trGotoGraphicalHierarchy()
    {
      return "�����̳й�ϵͼ";
    }

                virtual QCString trGotoTextualHierarchy()
    {
      return "�����̳й�ϵ��";
    }

                virtual QCString trPageIndex()
    {
      return "ҳ������";
    }

// new since 1.1.0
    
                virtual QCString trNote()
    {
      return "ע��";
    }

                virtual QCString trPublicTypes()
    {
      return "��������";
    }

                virtual QCString trPublicAttribs()
    {
                         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                         { 
                                 return "���ݳ�Ա";
                         }
                         else {
                                 return "��������";
                         }
    }

                virtual QCString trStaticPublicAttribs()
    {
      return "��̬��������";
    }

                virtual QCString trProtectedTypes()
    {
      return "��������";
    }

                virtual QCString trProtectedAttribs()
    {
      return "��������";
    }

                virtual QCString trStaticProtectedAttribs()
    {
      return "��̬��������";
    }

                virtual QCString trPrivateTypes()
    {
      return "˽������";
    }

                virtual QCString trPrivateAttribs()
    {
      return "˽������";
    }

                virtual QCString trStaticPrivateAttribs()
    {
      return "��̬˽������";
    }


// new since 1.1.3

                virtual QCString trTodo()
    {
      return "TODO";
    }

                virtual QCString trTodoList()
    {
      return "TODO"CN_SPC"�б�";
    }

// new since 1.1.4

                virtual QCString trReferencedBy()
    {
      return "���";
    }

                virtual QCString trRemarks()
    {
      return "����";
    }

                virtual QCString trAttention()
    {
      return "ע��";
    }

                virtual QCString trInclByDepGraph()
    {
      return "��ͼչʾֱ�ӻ��Ӱ������ļ����ļ���";
    }

                virtual QCString trSince()
    {
      return "�Դ�";
    }
    
// new since 1.1.5

                virtual QCString trLegendTitle()
    {
      return "ͼ��";
    }

                virtual QCString trLegendDocs()
    {
      return 
        "��ҳ����չʾ���������"CN_SPC"Doxygen"CN_SPC"���ɵ�ͼ�Ρ�<p>\n"
        "�뿼������ʾ����\n"
        "\\code\n"
        "/*! ���ڽ�ȡ��ʹ���಻�ɼ� */\n"
        "class Invisible { };\n\n"
        "/*! ����ȡ���࣬�̳й�ϵ������������ */\n"
        "class Truncated : public Invisible { };\n\n"
        "/* û�б�"CN_SPC"doxygen"CN_SPC"��ע���ĵ������� */\n"
        "class Undocumented { };\n\n"
        "/*! �����м̳е��� */\n"
        "class PublicBase : public Truncated { };\n\n"
        "/*! A template class */\n"
        "template<class T> class Templ { };\n\n"
        "/*! �������̳е��� */\n"
        "class ProtectedBase { };\n\n"
        "/*! ��˽�м̳е��� */\n"
        "class PrivateBase { };\n\n"
        "/*! ��ʹ�õ��� */\n"
        "class Used { };\n\n"
        "/*! �̳���������������� */\n"
        "class Inherited : 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"
        "����������ļ���ָ����"CN_SPC"MAX_DOT_GRAPH_HEIGHT"CN_SPC"��ֵΪ200��"
        "��Doxygen���������µ�ͼ�Σ�"
        "<p><center><img src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
        "<p>\n"
        "����ͼ���еľ��������µĺ��壺\n"
        "<ul>\n"
        "<li>����ɫ���ľ��δ�����ǰ�����ṹ��\n"
        "<li>��ɫ�߿�ľ��δ���<i>�ĵ���</i>�����ṹ��\n"
        "<li>��ɫ�߿�ľ��δ���û��<i>�ĵ���</i>�����ṹ��\n"
        "<li>��ɫ�߿�ľ��δ����̳�/������ϵû�б�������ʾ�������ṹ�����һ��ͼ��ij�"
        "�����ָ���ߴ磬��������ȡ��"
        "</ul>\n"
        "������ͷ�����µĺ��壺\n"
        "<ul>\n"
        "<li>����ɫ�ļ�ͷ������ʾ������֮��Ĺ��м̳й�ϵ��\n"
        "<li>����ɫ�ļ�ͷ������ʾ�����̳й�ϵ��\n"
        "<li>���ɫ�ļ�ͷ������ʾ˽�м̳й�ϵ��\n"
        "<li>��ɫ��״�����ļ�ͷ������ʾ������֮���������ʹ�õĹ�ϵ��ͨ����ͷ�Աߵı�������"
        "���ʵ���ͷ��ָ�����ṹ��\n"
        "</ul>\n";
    }
                virtual QCString trLegend()
    {
      return "ͼ��";
    }

// new since 1.2.0
    
    virtual QCString trTest()
    {
      return "����";
    }

    virtual QCString trTestList()
    {
      return "�����б�";
    }


                virtual QCString trDCOPMethods()
                {
                        return "DCOP"CN_SPC"����";
                }


                virtual QCString trProperties()
                {
                        return "����";
                }

                virtual QCString trPropertyDocumentation()
                {
                        return "�����ĵ�";
                }

// new since 1.2.4

    virtual QCString trClasses()
    {
                        if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
                        {
                                return "���ݽṹ";
                        }
                        else
                        {
                                return "��";
                        }
    }

    virtual QCString trPackage(const char *name)
    {
      return (QCString)"�� "+name;
    }
                
    virtual QCString trPackageList()
    {
      return "���б�";
    }

    virtual QCString trPackageListDescription()
    {
                         return "�����г����еİ���������Ҫ˵��(����еĻ�)��"; 
    }

    virtual QCString trPackages()
    {
      return "��";
    }

    virtual QCString trDefineValue()
    {
      return    "ֵ:";
    }

                virtual QCString trBug ()
                {
                        return "ȱ��";
                }

                virtual QCString trBugList ()
                {
                        return "ȱ���б�";
                }

// new since 1.2.6

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

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


    virtual QCString trRTFGeneralIndex()
    {
      return "����";
    }

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

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

    }

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

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

    virtual QCString trPage(bool /*first_capital*/, bool /*singular*/)
    { 
                        /*
                QCString result((first_capital ? "Page" : "page"));
      if (!singular)  result+="s";
      return result; 
                        */
                        return "ҳ";
    }

    virtual QCString trMember(bool /*first_capital*/, bool /*singular*/)
    { 
                        /*
                QCString result((first_capital ? "Member" : "member"));
      if (!singular)  result+="s";
      return result; 
                        */
                        return "��Ա";
    }
   
    virtual QCString trGlobal(bool /*first_capital*/, bool /*singular*/)
    { 
                        /*
                QCString result((first_capital ? "Global" : "global"));
      if (!singular)  result+="s";
      return result; 
                        */
                        return "ȫ�ֶ���";
    }

// new since 1.2.7

    virtual QCString trAuthor(bool /*first_capital*/, bool /*singular*/)
    {                                                                         
                        /*
                QCString result((first_capital ? "Author" : "author"));
      if (!singular)  result+="s";
      return result; 
                        */
                        return "����";
    }

// new since 1.2.11

    virtual QCString trReferences()
    {
      return "�ο�";
    }

// new since 1.2.13

    virtual QCString trImplementedFromList(int numEntries)
    {
      /* return "Implements "+trWriteList(numEntries)+"."; */
      return "ʵ����"CN_SPC+trWriteList(numEntries)+"��";
    }

    virtual QCString trImplementedInList(int numEntries)
    {
      /* return "Implemented in "+trWriteList(numEntries)+"."; */
      return "��"CN_SPC+trWriteList(numEntries)+CN_SPC"�ڱ�ʵ�֡�";
    }

// new since 1.2.16

    virtual QCString trRTFTableOfContents()
    {
      /* return "Table of Contents"; */
      return "Ŀ¼";
    }

// new since 1.2.17

    virtual QCString trDeprecatedList()
    {
/*    return "Deprecated List";  */
      return "��ʱ�б�";
    }

// new since 1.2.18

    virtual QCString trEvents()
    {
      /*      return "Events"; */
      return "�¼�";
    }
    virtual QCString trEventDocumentation()
    {
      /* return "Event Documentation"; */
      return "�¼��ĵ�";
    }

// new since 1.3

    virtual QCString trPackageTypes()
    { 
      /* return "Package Types"; */
      return "ģ������";
    }
    virtual QCString trPackageMembers()
    { 
      /* return "Package Functions"; */
      return "ģ�麯��";
    }
    virtual QCString trStaticPackageMembers()
    { 
      /* return "Static Package Functions"; */
      return "��̬ģ�麯��";
    }
    virtual QCString trPackageAttribs()
    { 
      /* return "Package Attributes"; */
      return "ģ������";
    }
    virtual QCString trStaticPackageAttribs()
    { 
      /* return "Static Package Attributes"; */
      return "��̬ģ������";
    }
    
// new since 1.3.1

    virtual QCString trAll()
    {
      /* return "All"; */
      return "ȫ��";
    }
    virtual QCString trCallGraph()
    {
      /* return "Here is the call graph for this function:"; */
      return "��������ͼ:";
    }

// new since 1.3.3

    virtual QCString trSearchForIndex()
    {
      /* return "Search for"; */
      return "����";
    }
    virtual QCString trSearchResultsTitle()
    {
      /* return "Search Results"; */
      return "�������";
    }
    virtual QCString trSearchResults(int numDocuments)
    {
      if (numDocuments==0)
      {
        /* return "Sorry, no documents matching your query."; */
        return "�Բ����Ҳ�������IJ�ѯ������ĵ���";
      }
      else if (numDocuments==1)
      {
        /* return "Found <b>1</b> document matching your query."; */
        return "�ҵ�<b>1</b>ƪ����IJ�ѯ������ĵ���";
      }
      else 
      {
        /* return "Found <b>$num</b> documents matching your query. "
               "Showing best matches first."; */
        return "�ҵ�<b>$num</b>ƪ����IJ�ѯ������ĵ���"
               "����ʾ���Ǻϵ��ĵ���";
      }
    }
    virtual QCString trSearchMatches()
    {
      /* return "Matches:"; */
      return "���ϵĽ��:";
    }

// new since 1.3.8

    virtual QCString trSourceFile(QCString& filename)
    {
      /* return filename + " Source File"; */
      return filename + CN_SPC"Դ�ļ�";
    }
// new since 1.3.9

    virtual QCString trDirIndex()
    /*     { return "Directory Hierarchy"; } */
    {
      return "Ŀ¼�ṹ";
    }

    virtual QCString trDirDocumentation()
    /*     { return "Directory Documentation"; } */
    {
      return "Ŀ¼�ĵ�";
    }

    virtual QCString trDirectories()
    /*     { return "Directories"; } */
    {
      return "Ŀ¼";
    }

    virtual QCString trDirDescription()
/*     { return "This directory hierarchy is sorted roughly, " */
/*              "but not completely, alphabetically:"; */
/*     } */
    {
      return "Ŀ¼�ṹ���������Ե�����";
    }

    virtual QCString trDirReference(const char *dirName)
    /*     { QCString result=dirName; result+=" Directory Reference"; return result; } */
    {
      QCString result=dirName;
      result+=CN_SPC"Ŀ¼�ο�"; 
      return result;
    }

    virtual QCString trDir(bool, bool)
    { 
      /*       QCString result((first_capital ? "Director" : "director")); */
      /*       if (singular) result+="y"; else result+="ies"; */
      /*       return result;  */
      return "Ŀ¼";
    }
    
// new since 1.4.1

    virtual QCString trOverloadText()
    {
       /* return "This is an overloaded member function, "
              "provided for convenience. It differs from the above "
              "function only in what argument(s) it accepts."; */
      return "����Ϊ����ʹ�ö��ṩ��һ�����س�Ա������"
             "������ĺ�����ȣ������ܲ�ͬ���͵IJ�����";
    }

// new since 1.4.6

    virtual QCString trCallerGraph()
    {
      /* return "Here is the caller graph for this function:"; */
      return "������������ĵ���ͼ��";
    }

    virtual QCString trEnumerationValueDocumentation()
    { 
      /* return "Enumerator Documentation"; */
      return "ö�ٱ����ĵ�";
    }

// new since 1.5.4 (mainly for Fortran)
    
    virtual QCString trMemberFunctionDocumentationFortran()
    // { return "Member Function/Subroutine Documentation"; }
    { return "��Ա�����������ĵ�"; }

    virtual QCString trCompoundListFortran()
    // { return "Data Types List"; }
    { return "���������б�"; }

    virtual QCString trCompoundMembersFortran()
    // { return "Data Fields"; }
    { return "������"; }

    virtual QCString trCompoundListDescriptionFortran()
    // { return "Here are the data types with brief descriptions:"; }
    { return "����Ҫ���������������б�:"; }

    virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
    {
    //   QCString result="Here is a list of all ";
    //   if (!extractAll)
    //   {
    //     result+="documented ";
    //   }
    //   result+="data types members";
    //   result+=" with links to ";
    //   if (!extractAll) 
    //   {
    //      result+="the data structure documentation for each member";
    //   }
    //   else 
    //   {
    //      result+="the data types they belong to:";
    //   }
    //   return result;
      if(!extractAll) {
        return "���������ĵ����������ͳ�Ա�б������е�ÿ����Ա�����ݽṹ�ĵ�������";
      } else {
        return "�������������ͳ�Ա�б������е���Ա�������������͵�����:";
      }

    }

    virtual QCString trCompoundIndexFortran()
    // { return "Data Type Index"; }
    { return "������������"; }


    virtual QCString trTypeDocumentation()
    // { return "Data Type Documentation"; }
    { return "���������ĵ�"; }

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

    virtual QCString trSubprogramDocumentation()
    //{ return "Function/Subroutine Documentation"; }
    { return "����/�����ĵ�"; }


     virtual QCString trDataTypes()
    // { return "Data Types"; }
    { return "��������"; }
    
    virtual QCString trModulesList()
    // { return "Modules List"; }
    { return "ģ���б�"; }

    virtual QCString trModulesListDescription(bool extractAll)
    {
      // QCString result="Here is a list of all ";
      // if (!extractAll) result+="documented ";
      // result+="modules with brief descriptions:";
      // return result;
      if(!extractAll) {
        return "����Ҫ���������ĵ���ģ���б�:";
      } else {
        return "����Ҫ������ģ���б�:";
      }
    }

    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;
      // }
      // if (isTemplate) result+=" Template";
      // result+=" Reference";
      // return result;
      QCString result=(QCString)clName;
      switch(compType)
      {
        case ClassDef::Class:      result+=CN_SPC"ģ��"; break;
        case ClassDef::Struct:     result+=CN_SPC"����"; break;
        case ClassDef::Union:      result+=CN_SPC"����"; break;
        case ClassDef::Interface:  result+=CN_SPC"����"; break;
        case ClassDef::Protocol:   result+=CN_SPC"�ӿ�"; break;
        case ClassDef::Category:   result+=CN_SPC"Ŀ¼"; break;
        case ClassDef::Exception:  result+=CN_SPC"�쳣"; break;
      }
      if (isTemplate) result+="ģ��";
      result+="�ο��ֲ�";
      return result;
    }
    virtual QCString trModuleReference(const char *namespaceName)
    {
      QCString result=namespaceName;
      // result+=" Module Reference";        
      result += CN_SPC"ģ��ο��ֲ�";
      return result;
    }
    
    virtual QCString trModulesMembers()
    // { return "Module Members"; }
    { return "ģ���Ա"; }

    virtual QCString trModulesMemberDescription(bool extractAll)
    { 
      // QCString result="Here is a list of all ";
      // if (!extractAll) result+="documented ";
      // result+="module members with links to ";
      // if (extractAll) 
      // {
      //   result+="the module documentation for each member:";
      // }
      // else 
      // {
      //   result+="the modules they belong to:";
      // }
      // return result;
      if(!extractAll) {
        return "���������ĵ���ģ���Ա�б������е�ÿ����Ա����ģ����ĵ�������";
      } else {
        return "������ģ���Ա�б������е���Ա������ģ�������:";
      }
    }

    virtual QCString trModulesIndex()
    // { return "Modules Index"; }
    { return "ģ������"; }
    
    virtual QCString trModule(bool, bool)
    {       
      // QCString result((first_capital ? "Module" : "module"));
      // if (!singular)  result+="s";
      // return result; 
      return "ģ��";
    }
    virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
        bool)
    { // here s is one of " Module", " Struct" or " Union"
      // single is true implies a single file
      // QCString result=(QCString)"The documentation for this ";
      // 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;
      // }
      // result+=" was generated from the following file";
      // if (single) result+=":"; else result+="s:";
      // return result;
      QCString result="��";
      switch(compType)
      {
        case ClassDef::Class:      result+=CN_SPC"ģ��"; break;
        case ClassDef::Struct:     result+=CN_SPC"����"; break;
        case ClassDef::Union:      result+=CN_SPC"����"; break;
        case ClassDef::Interface:  result+=CN_SPC"����"; break;
        case ClassDef::Protocol:   result+=CN_SPC"�ӿ�"; break;
        case ClassDef::Category:   result+=CN_SPC"Ŀ¼"; break;
        case ClassDef::Exception:  result+=CN_SPC"�쳣"; break;
      }
      result+="���ĵ��������ļ�����:";
      return result;
    }
    virtual QCString trType(bool, bool)
    { 
      return "����";
    }
    virtual QCString trSubprogram(bool, bool)
    { 
      return "�ӳ���";
    }

    virtual QCString trTypeConstraints()
    {
      return "��������";
    }
};

#endif

---

• ソフトウェア開発
• ホームページ制作
• Tcl版
• STLport版
• Dradnats C++ Library
• 要約文庫