translator_kr.h

Go to the documentation of this file.
00001 /******************************************************************************
00002  *
00003  * 
00004  *
00005  * Copyright (C) 1997-2008 by Dimitri van Heesch.
00006  *
00007  * Permission to use, copy, modify, and distribute this software and its
00008  * documentation under the terms of the GNU General Public License is hereby 
00009  * granted. No representations are made about the suitability of this software 
00010  * for any purpose. It is provided "as is" without express or implied warranty.
00011  * See the GNU General Public License for more details.
00012  *
00013  * Documents produced by Doxygen are derivative works derived from the
00014  * input used in their production; they are not affected by this license.
00015  *
00016  */
00017 
00018 #ifndef TRANSLATOR_KR_H
00019 #define TRANSLATOR_KR_H
00020 
00021 
00022 /* Korean translators
00023  * doxygen-svn
00024  *   * fly1004@gmail.com
00025  * doxygen-1.5.3
00026  *   * Astromaker(http://ngps.net/)
00027  *   * gpgiki(http://www.gpgstudy.com/gpgiki/)
00028  * doxygen-1.2.11
00029  *   * ryk */
00030 
00053 class TranslatorKorean : public Translator
00054 {
00055   protected:
00056     friend class TranslatorAdapterBase;
00057     virtual ~TranslatorKorean() {}
00058 
00059   public:
00060 
00061     // --- Language control methods -------------------
00062     
00069     virtual QCString idLanguage()
00070     { return "korean"; }
00071     
00086     virtual QCString latexLanguageSupportCommand()
00087     {
00088       // I'm not sure what this should be.
00089       // When I figure it out, I'll update this.
00090       // see http://www.ktug.or.kr/jsboard/read.php?table=operate&no=4422&page=1
00091       return "\\usepackage{hfont}\n";
00092     }
00093 
00095     virtual QCString idLanguageCharset()
00096     {
00097       return "euc-kr";
00098     }
00099 
00100     // --- Language translation methods -------------------
00101 
00103     virtual QCString trRelatedFunctions()
00104     { return "õ Լ"; }
00105 
00107     virtual QCString trRelatedSubscript()
00108     { return "(  Լ ƴմϴ. Ͻʽÿ.)"; }
00109 
00111     virtual QCString trDetailedDescription()
00112     { return " "; }
00113 
00115     virtual QCString trMemberTypedefDocumentation()
00116     { return " Ÿ ȭ"; }
00117     
00119     virtual QCString trMemberEnumerationDocumentation()
00120     { return "  ȭ"; }
00121     
00123     virtual QCString trMemberFunctionDocumentation()
00124     { return " Լ ȭ"; }
00125     
00127     virtual QCString trMemberDataDocumentation()
00128     { 
00129       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00130       {
00131           return "ʵ ȭ";
00132       }
00133       else
00134       {
00135           return " Ÿ ȭ";
00136       }
00137     }
00138 
00140     virtual QCString trMore() 
00141     { return " ڼ ..."; }
00142 
00144     virtual QCString trListOfAllMembers()
00145     { return "  "; }
00146 
00148     virtual QCString trMemberList()
00149     { return " "; }
00150 
00152     virtual QCString trThisIsTheListOfAllMembers()
00153     { return "    Դϴ : "; }
00154 
00156     virtual QCString trIncludingInheritedMembers()
00157     { return " ( ӵ 鵵 մϴ.)"; }
00158     
00162     virtual QCString trGeneratedAutomatically(const char *s)
00163     { QCString result="ҽ ڵκ ";
00164       if (s) result+=s+(QCString)"  ";
00165       result+="Doxygen  ڵ ."; 
00166       return result;
00167     }
00168 
00170     virtual QCString trEnumName()
00171     { return " ̸"; }
00172     
00174     virtual QCString trEnumValue()
00175     { return " "; }
00176     
00178     virtual QCString trDefinedIn()
00179     { return " ǵ :"; }
00180 
00181     // quick reference sections
00182 
00186     virtual QCString trModules()
00187     { return ""; }
00188     
00190     virtual QCString trClassHierarchy()
00191     { return "Ŭ 뵵"; }
00192     
00194     virtual QCString trCompoundList()
00195     { 
00196       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00197       {
00198         return "Ÿ ";
00199       }
00200       else
00201       {
00202         return "Ŭ "; 
00203       }
00204     }
00205     
00207     virtual QCString trFileList()
00208     { return " "; }
00209 
00211     virtual QCString trCompoundMembers()
00212     { 
00213       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00214       {
00215         return "Ÿ ʵ"; 
00216       }
00217       else
00218       {
00219         return "Ŭ "; 
00220       }
00221     }
00222 
00224     virtual QCString trFileMembers()
00225     { 
00226       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00227       {
00228         return ""; 
00229       }
00230       else
00231       {
00232         return " "; 
00233       }
00234     }
00235 
00237     virtual QCString trRelatedPages()
00238     { return "õ "; }
00239 
00241     virtual QCString trExamples()
00242     { return ""; }
00243 
00245     virtual QCString trSearch()
00246     { return "˻"; }
00247 
00249     virtual QCString trClassHierarchyDescription()
00250     { return "     ĺ 뷫 ĵǾֽϴ.:";
00251     }
00252 
00254     virtual QCString trFileListDescription(bool extractAll)
00255     {
00256       QCString result=" ";
00257       if (!extractAll) result+="ȭ ";
00258       result+=" Ͽ  Դϴ. (  ݴϴ) :";
00259       return result;
00260     }
00261 
00263     virtual QCString trCompoundListDescription()
00264     { 
00265       
00266       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00267       {
00268         return " Ÿ Դϴ. (  ݴϴ) :"; 
00269       }
00270       else
00271       {
00272         return " Ŭ, ü, ü ׸ ̽Դϴ. "
00273                "(  ݴϴ) :"; 
00274       }
00275     }
00276 
00278     virtual QCString trCompoundMembersDescription(bool extractAll)
00279     {
00280       QCString result=" ";
00281       if (!extractAll)
00282       {
00283         result+="ȭ ";
00284       }
00285       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00286       {
00287         result+=" ü ü ʵ";
00288       }
00289       else
00290       {
00291         result+=" Ŭ ";
00292       }
00293       result+=" Դϴ. ";
00294 
00295       if (!extractAll) 
00296       {
00297         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00298         {
00299           result+=" ʵ ش ʵ忡  ü ü "
00300                   "ȭ  ũ  ֽϴ. :";
00301         }
00302         else
00303         {
00304           result+="  ش   Ŭ ȭ  "
00305                   "ũ  ֽϴ. :";
00306         }
00307       }
00308       else 
00309       {
00310         if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00311         {
00312           result+=" ʵ ش ʵ尡  ִ ü ü "
00313                   " ũ  ֽϴ. :";
00314         }
00315         else
00316         {
00317           result+="  ش   ִ Ŭ  "
00318                   "ũ  ֽϴ. :";
00319         }
00320       }
00321       return result;
00322     }
00323 
00325     virtual QCString trFileMembersDescription(bool extractAll)
00326     {
00327       QCString result=" ";
00328       if (!extractAll) result+="ȭ  ";
00329       
00330       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00331       {
00332         result+=" Լ, , ũ, , Ÿǵ";
00333       }
00334       else
00335       {
00336         result+=" ";
00337       }
00338       result+=" Դϴ. ";
00339 
00340       result+=" ׸ ";
00341       if (extractAll) 
00342         result+="׵    ũ  ֽϴ. :";
00343       else 
00344         result+="׵鿡  ȭ  ũ  ֽϴ. :";
00345       return result;
00346     }
00347 
00349     virtual QCString trExamplesDescription()
00350     { return "   Դϴ.:"; }
00351 
00353     virtual QCString trRelatedPagesDescription()
00354     { return " õ  ȭ  Դϴ.:"; }
00355 
00357     virtual QCString trModulesDescription()
00358     { return "   Դϴ.:"; }
00359 
00360     // index titles (the project name is prepended for these) 
00361 
00363     virtual QCString trDocumentation()
00364     { return "ȭ"; }
00365 
00369     virtual QCString trModuleIndex()
00370     { return " "; }
00371 
00375     virtual QCString trHierarchicalIndex()
00376     { return "뵵 "; }
00377 
00381     virtual QCString trCompoundIndex()
00382     {
00383       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00384       { 
00385         return "Ÿ  ";
00386       }
00387       else
00388       {
00389         return "Ŭ "; 
00390       }
00391     }
00392 
00396     virtual QCString trFileIndex() 
00397     { return " "; }
00398 
00402     virtual QCString trModuleDocumentation()
00403     { return " ȭ"; }
00404 
00408     virtual QCString trClassDocumentation()
00409     { 
00410       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00411       {
00412         return "Ÿ  ȭ"; 
00413       }
00414       else
00415       {
00416         return "Ŭ ȭ"; 
00417       }
00418     }
00419 
00423     virtual QCString trFileDocumentation()
00424     { return " ȭ"; }
00425 
00429     virtual QCString trExampleDocumentation()
00430     { return " ȭ"; }
00431 
00435     virtual QCString trPageDocumentation()
00436     { return " ȭ"; }
00437 
00439     virtual QCString trReferenceManual()
00440     { return " Ŵ"; }
00441     
00445     virtual QCString trDefines()
00446     { return "ũ"; }
00447 
00451     virtual QCString trFuncProtos()
00452     { return "Լ "; }
00453 
00457     virtual QCString trTypedefs()
00458     { return "Ÿ"; }
00459 
00463     virtual QCString trEnumerations()
00464     { return " Ÿ"; }
00465 
00469     virtual QCString trFunctions()
00470     { return "Լ"; }
00471 
00475     virtual QCString trVariables()
00476     { return ""; }
00477 
00481     virtual QCString trEnumerationValues()
00482     { return " "; }
00483     
00487     virtual QCString trDefineDocumentation()
00488     { return "ũ ȭ"; }
00489 
00493     virtual QCString trFunctionPrototypeDocumentation()
00494     { return "Լ  ȭ"; }
00495 
00499     virtual QCString trTypedefDocumentation()
00500     { return "Ÿ ȭ"; }
00501 
00505     virtual QCString trEnumerationTypeDocumentation()
00506     { return " Ÿ ȭ"; }
00507 
00511     virtual QCString trFunctionDocumentation()
00512     { return "Լ ȭ"; }
00513 
00517     virtual QCString trVariableDocumentation()
00518     { return " ȭ"; }
00519 
00523     virtual QCString trCompounds()
00524     { 
00525       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00526       {
00527         return "Ÿ "; 
00528       }
00529       else
00530       {
00531         return "Ŭ"; 
00532       }
00533     }
00534 
00538     virtual QCString trGeneratedAt(const char *date,const char *projName)
00539     { 
00540       QCString result=(QCString)"ð : "+date;
00541       if (projName) result+=(QCString)", Ʈ : "+projName;
00542       result+=(QCString)",  : ";
00543       return result;
00544     }
00547     virtual QCString trWrittenBy()
00548     {
00549       return "ۼ : ";
00550     }
00551 
00553     virtual QCString trClassDiagram(const char *clName)
00554     {
00555       return (QCString)clName+"   ̾׷ : ";
00556     }
00557     
00559     virtual QCString trForInternalUseOnly()
00560     { return "θ ϱ ."; }
00561 
00563     virtual QCString trWarning()
00564     { return ""; }
00565 
00567     virtual QCString trVersion()
00568     { return ""; }
00569 
00571     virtual QCString trDate()
00572     { return "¥"; }
00573 
00575     virtual QCString trReturns()
00576     { return "ȯ"; }
00577 
00579     virtual QCString trSeeAlso()
00580     { return ""; }
00581 
00583     virtual QCString trParameters()
00584     { return "Ű"; }
00585 
00587     virtual QCString trExceptions()
00588     { return ""; }
00589     
00591     virtual QCString trGeneratedBy()
00592     { return "   : "; }
00593 
00595 // new since 0.49-990307
00597     
00599     virtual QCString trNamespaceList()
00600     { return "ӽ̽ "; }
00601 
00603     virtual QCString trNamespaceListDescription(bool extractAll)
00604     {
00605       QCString result=" ";
00606       if (!extractAll) result+="ȭ ";
00607       result+=" ӽ̽  Դϴ. (  ݴϴ) :";
00608       return result;
00609     }
00610 
00614     virtual QCString trFriends()
00615     { return "Friends"; }
00616     
00618 // new since 0.49-990405
00620     
00624     virtual QCString trRelatedFunctionDocumentation()
00625     { return "Friend, ׸ õ Լ ȭ"; }
00626     
00628 // new since 0.49-990425
00630 
00632     virtual QCString trCompoundReference(const char *clName,
00633                                     ClassDef::CompoundType compType,
00634                                     bool isTemplate)
00635     {
00636       QCString result=(QCString)clName;
00637       switch(compType)
00638       {
00639         case ClassDef::Class:      result+=" Ŭ"; break;
00640         case ClassDef::Struct:     result+=" ü"; break;
00641         case ClassDef::Union:      result+=" ü"; break;
00642         case ClassDef::Interface:  result+=" ̽"; break;
00643         case ClassDef::Protocol:   result+=" "; break;
00644         case ClassDef::Category:   result+=" īװ"; break;
00645         case ClassDef::Exception:  result+=" "; break;
00646       }
00647       if (isTemplate) result+=" ø";
00648       result+=" ";
00649       return result;
00650     }
00651 
00653     virtual QCString trFileReference(const char *fileName)
00654     {
00655       QCString result=fileName;
00656       result+="  ";
00657       return result;
00658     }
00659 
00661     virtual QCString trNamespaceReference(const char *namespaceName)
00662     {
00663       QCString result=namespaceName;
00664       result+=" ӽ̽ ";
00665       return result;
00666     }
00667     
00668     virtual QCString trPublicMembers()
00669     { return "Public  Լ"; }
00670     virtual QCString trPublicSlots()
00671     { return "Public Slots"; }
00672     virtual QCString trSignals()
00673     { return "Signals"; }
00674     virtual QCString trStaticPublicMembers()
00675     { return " Public  Լ"; }
00676     virtual QCString trProtectedMembers()
00677     { return "Protected  Լ"; }
00678     virtual QCString trProtectedSlots()
00679     { return "Protected Slots"; }
00680     virtual QCString trStaticProtectedMembers()
00681     { return " Protected  Լ"; }
00682     virtual QCString trPrivateMembers()
00683     { return "Private  Լ"; }
00684     virtual QCString trPrivateSlots()
00685     { return "Private Slots"; }
00686     virtual QCString trStaticPrivateMembers()
00687     { return " Private  Լ"; }
00688     
00692     virtual QCString trWriteList(int numEntries)
00693     {
00694       QCString result;
00695       int i;
00696       // the inherits list contain `numEntries' classes
00697       for (i=0;i<numEntries;i++) 
00698       {
00699         // use generateMarker to generate placeholders for the class links!
00700         result+=generateMarker(i); // generate marker for entry i in the list 
00701                                    // (order is left to right)
00702         
00703         if (i!=numEntries-1)  // not the last entry, so we need a separator
00704         {
00705           if (i<numEntries-2) // not the fore last entry 
00706             result+=", ";
00707           else                // the fore last entry
00708             result+=", ";
00709         }
00710       }
00711       return result; 
00712     }
00713     
00717     virtual QCString trInheritsList(int numEntries)
00718     {
00719       return trWriteList(numEntries)+"() ߽ϴ.";
00720     }
00721 
00725     virtual QCString trInheritedByList(int numEntries)
00726     {
00727       return trWriteList(numEntries)+"  ӵǾϴ.";
00728     }
00729 
00733     virtual QCString trReimplementedFromList(int numEntries)
00734     {
00735       return trWriteList(numEntries)+"()κ 籸Ǿϴ.";
00736     }
00737 
00741     virtual QCString trReimplementedInList(int numEntries)
00742     {
00743       return trWriteList(numEntries)+" 籸Ǿϴ.";
00744     }
00745 
00747     virtual QCString trNamespaceMembers()
00748     { return "ӽ̽ "; }
00749 
00751     virtual QCString trNamespaceMemberDescription(bool extractAll)
00752     { 
00753       QCString result=" ";
00754       if (!extractAll) result+="ȭ ";
00755       result+=" ӽ̽  Դϴ. ";
00756       if (extractAll) 
00757         result+="  ش  ӽ̽ ȭ  ũ  ֽϴ. :";
00758       else 
00759         result+="  ش   ӽ̽  ũ  ֽϴ. :";
00760       return result;
00761     }
00765     virtual QCString trNamespaceIndex()
00766     { return "ӽ̽ "; }
00767 
00771     virtual QCString trNamespaceDocumentation()
00772     { return "ӽ̽ ȭ"; }
00773 
00775 // new since 0.49-990522
00777 
00781     virtual QCString trNamespaces()
00782     { return "ӽ̽"; }
00783 
00785 // new since 0.49-990728
00787 
00791     virtual QCString trGeneratedFromFiles(ClassDef::CompoundType compType,
00792         bool single)
00793     { // here s is one of " Class", " Struct" or " Union"
00794       // single is true implies a single file
00795       QCString result=(QCString)" ";
00796       switch(compType)
00797       {
00798         case ClassDef::Class:      result+="Ŭ"; break;
00799         case ClassDef::Struct:     result+="ü"; break;
00800         case ClassDef::Union:      result+="ü"; break;
00801         case ClassDef::Interface:  result+="̽"; break;
00802         case ClassDef::Protocol:   result+=""; break;
00803         case ClassDef::Category:   result+="īװ"; break;
00804         case ClassDef::Exception:  result+=""; break;
00805       }
00806       result+="  ȭ   ";
00807       if (!single) result+="";
00808       result+="κ Ǿϴ.:";
00809       return result;
00810     }
00811 
00815     virtual QCString trAlphabeticalList()
00816     { return "ĺ "; }
00817 
00819 // new since 0.49-990901
00821 
00823     virtual QCString trReturnValues()
00824     { return "ȯ"; }
00825 
00828     virtual QCString trMainPage()
00829     { return " "; }
00830 
00834     virtual QCString trPageAbbreviation()
00835     { return ""; }
00836 
00838 // new since 0.49-991003
00840 
00841     virtual QCString trDefinedAtLineInSourceFile()
00842     {
00843       return "@1  @0 ° ο ǵǾϴ.";
00844     }
00845     virtual QCString trDefinedInSourceFile()
00846     {
00847       return "@0 Ͽ ǵǾϴ.";
00848     }
00849 
00851 // new since 0.49-991205
00853 
00854     virtual QCString trDeprecated()
00855     {
00856       return "߸ ڵ";
00857     }
00858 
00860 // new since 1.0.0
00862 
00864     virtual QCString trCollaborationDiagram(const char *clName)
00865     {
00866       return (QCString)clName+"   ̾׷:";
00867     }
00869     virtual QCString trInclDepGraph(const char *fName)
00870     {
00871       return (QCString)fName+"  include  ׷";
00872     }
00874     virtual QCString trConstructorDocumentation()
00875     {
00876       return " & Ҹ ȭ";
00877     }
00879     virtual QCString trGotoSourceCode()
00880     {
00881       return "  ҽ ڵ  ";
00882     }
00884     virtual QCString trGotoDocumentation()
00885     {
00886       return "  ȭ  ";
00887     }
00889     virtual QCString trPrecondition()
00890     {
00891       return "";
00892     }
00894     virtual QCString trPostcondition()
00895     {
00896       return "Ĺ";
00897     }
00899     virtual QCString trInvariant()
00900     {
00901       return " ʴ";
00902     }
00904     virtual QCString trInitialValue()
00905     {
00906       return "ʱⰪ:";
00907     }
00909     virtual QCString trCode()
00910     {
00911       return "ڵ";
00912     }
00913     virtual QCString trGraphicalHierarchy()
00914     {
00915       return "׷ Ŭ 뵵";
00916     }
00917     virtual QCString trGotoGraphicalHierarchy()
00918     {
00919       return "׷ Ŭ 뵵  ";
00920     }
00921     virtual QCString trGotoTextualHierarchy()
00922     {
00923       return "ؽƮ  Ŭ 뵵  ";
00924     }
00925     virtual QCString trPageIndex()
00926     {
00927       return " ";
00928     }
00929 
00931 // new since 1.1.0
00933     
00934     virtual QCString trNote()
00935     {
00936       return "";
00937     }
00938     virtual QCString trPublicTypes()
00939     {
00940       return "Public Ÿ";
00941     }
00942     virtual QCString trPublicAttribs()
00943     {
00944       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
00945       {
00946         return "Ÿ ʵ";
00947       }
00948       else
00949       {
00950         return "Public Ӽ";
00951       }
00952     }
00953     virtual QCString trStaticPublicAttribs()
00954     {
00955       return " Public Ӽ";
00956     }
00957     virtual QCString trProtectedTypes()
00958     {
00959       return "Protected Ÿ";
00960     }
00961     virtual QCString trProtectedAttribs()
00962     {
00963       return "Protected Ӽ";
00964     }
00965     virtual QCString trStaticProtectedAttribs()
00966     {
00967       return " Protected Ӽ";
00968     }
00969     virtual QCString trPrivateTypes()
00970     {
00971       return "Private Ÿ";
00972     }
00973     virtual QCString trPrivateAttribs()
00974     {
00975       return "Private Ӽ";
00976     }
00977     virtual QCString trStaticPrivateAttribs()
00978     {
00979       return " Private Ӽ";
00980     }
00981 
00983 // new since 1.1.3
00985 
00987     virtual QCString trTodo()
00988     {
00989       return "";
00990     }
00992     virtual QCString trTodoList()
00993     {
00994       return " ";
00995     }
00996 
00998 // new since 1.1.4
01000 
01001     virtual QCString trReferencedBy()
01002     {
01003       return " ؼ  : ";
01004     }
01005     virtual QCString trRemarks()
01006     {
01007       return "Remarks";
01008     }
01009     virtual QCString trAttention()
01010     {
01011         return "";
01012     }
01013     virtual QCString trInclByDepGraph()
01014     {
01015       return " ׷   / include ϴ ϵ ݴϴ.:";
01016     }
01017     virtual QCString trSince()
01018     {
01019       return "Since";
01020     }
01021     
01023 // new since 1.1.5
01025 
01027     virtual QCString trLegendTitle()
01028     {
01029       return "׷ ";
01030     }
01034     virtual QCString trLegendDocs()
01035     {
01036       return 
01037         "  doxygen   ׷ ϴ  մϴ.<p>\n"
01038         "  Ͻʽÿ.:\n"
01039         "\\code\n"
01040         "/*! Ǿ   ʴ Ŭ */\n"
01041         "class Invisible { };\n\n"
01042         "/*! Truncated Ŭ, Ӱ谡  */\n"
01043         "class Truncated : public Invisible { };\n\n"
01044         "/* doxygen ּ ؼ ȭ ʴ Ŭ */\n"
01045         "class Undocumented { };\n\n"
01046         "/*! public  ؼ ӵ Ŭ */\n"
01047         "class PublicBase : public Truncated { };\n\n"
01048         "/*! ø Ŭ */\n"
01049         "template<class T> class Templ { };\n\n"
01050         "/*! protected  ؼ ӵ Ŭ */\n"
01051         "class ProtectedBase { };\n\n"
01052         "/*! private  ؼ ӵ Ŭ */\n"
01053         "class PrivateBase { };\n\n"
01054         "/*! ӵǾ Ŭ  () Ǿ Ŭ */\n"
01055         "class Used { };\n\n"
01056         "/*! ٸ Ŭ ϴ  Ŭ */\n"
01057         "class Inherited : public PublicBase,\n"
01058         "                  protected ProtectedBase,\n"
01059         "                  private PrivateBase,\n"
01060         "                  public Undocumented,\n"
01061         "                  public Templ<int>\n"
01062         "{\n"
01063         "  private:\n"
01064         "    Used *m_usedClass;\n"
01065         "};\n"
01066         "\\endcode\n"
01067         " Ͽ \\c MAX_DOT_GRAPH_HEIGHT ±װ "
01068         "240 Ǿٸ,   ׷ µ Դϴ. :"
01069         "<p><center><img alt=\"\" src=\"graph_legend."+Config_getEnum("DOT_IMAGE_FORMAT")+"\"></center>\n"
01070         "<p>\n"
01071         " ׷ ڽ   ǹ̸ ϴ. :\n"
01072         "<ul>\n"
01073         "<li>%A ȸ ä ڽ  ׷   ü Ŭ ǹմϴ.\n"
01074         "<li>%A  ׵θ ڽ ȭ ü Ŭ ǹմϴ.\n"
01075         "<li>%A ȸ ׵θ ڽ ȭ  ü Ŭ ǹմϴ.\n"
01076         "<li>%A  ׵θ ڽ  ̳ ԰谡  ʴ "
01077         "ü Ŭ ǹմϴ."
01078         "%A  ׷  賻  , ׷ ߷ϴ.\n"
01079         "</ul>\n"
01080         "ȭǥ   ǹ̸ ϴ. :\n"
01081         "<ul>\n"
01082         "<li>%A ο Ķ ȭǥ  Ŭ  public   ǹմϴ.\n"
01083         "<li>%A ο λ ȭǥ protected   ǹմϴ.\n"
01084         "<li>%A ο  ȭǥ private   ǹմϴ.\n"
01085         "<li>%A   ȭǥ ٸ Ŭ  Եǰų Ǿ ǹմϴ. "
01086         "ȭǥ  ȭǥ Ű Ŭ ü ϴ () ٽϴ.\n"
01087         "<li>%A   ȭǥ ø νϽ  Ŭ  踦 ǹմϴ. "
01088         "ȭǥ  νϽ ø Ķͷ ٽϴ.\n"
01089         "</ul>\n";
01090     }
01092     virtual QCString trLegend()
01093     {
01094       return "";
01095     }
01096     
01098 // new since 1.2.0
01100     
01102     virtual QCString trTest()
01103     {
01104       return "׽Ʈ";
01105     }
01107     virtual QCString trTestList()
01108     {
01109       return "׽Ʈ ";
01110     }
01111 
01113 // new since 1.2.1
01115 
01117     virtual QCString trDCOPMethods()
01118     {
01119       return "DCOP  Լ";
01120     }
01121 
01123 // new since 1.2.2
01125 
01127     virtual QCString trProperties()
01128     {
01129       return "Ӽ";
01130     }
01132     virtual QCString trPropertyDocumentation()
01133     {
01134       return "Ӽ ȭ";
01135     }
01136 
01138 // new since 1.2.4
01140 
01142     virtual QCString trClasses()
01143     {
01144       if (Config_getBool("OPTIMIZE_OUTPUT_FOR_C"))
01145       {
01146         return "Ÿ ";
01147       }
01148       else
01149       {
01150         return "Ŭ";
01151       }
01152     }
01154     virtual QCString trPackage(const char *name)
01155     {
01156       return name+(QCString)" Ű";
01157     }
01159     virtual QCString trPackageList()
01160     {
01161       return "Ű ";
01162     }
01164     virtual QCString trPackageListDescription()
01165     {
01166       return " ŰԴϴ. (   ݴϴ) :";
01167     }
01169     virtual QCString trPackages()
01170     {
01171       return "Ű";
01172     }
01174     virtual QCString trDefineValue()
01175     {
01176       return ":";
01177     }
01178     
01180 // new since 1.2.5
01182     
01184     virtual QCString trBug()
01185     {
01186       return "";
01187     }
01189     virtual QCString trBugList()
01190     {
01191       return " ";
01192     }
01193 
01195 // new since 1.2.6
01197 
01223     virtual QCString trRTFansicp()
01224     {
01225       return "949";
01226     }
01227     
01228 
01232     virtual QCString trRTFCharSet()
01233     {
01234       return "129";
01235     }
01236 
01238     virtual QCString trRTFGeneralIndex()
01239     {
01240       return "";
01241     }
01242    
01247     virtual QCString trClass(bool first_capital, bool singular)
01248     { 
01249       QCString result((first_capital ? "Ŭ" : "Ŭ"));
01250       if (!singular)  result+="";
01251       return result; 
01252     }
01253 
01258     virtual QCString trFile(bool first_capital, bool singular)
01259     { 
01260       QCString result((first_capital ? "" : ""));
01261       if (!singular)  result+="";
01262       return result; 
01263     }
01264 
01269     virtual QCString trNamespace(bool first_capital, bool singular)
01270     { 
01271       QCString result((first_capital ? "ӽ̽" : "ӽ̽"));
01272       if (!singular)  result+="";
01273       return result; 
01274     }
01275 
01280     virtual QCString trGroup(bool first_capital, bool singular)
01281     { 
01282       QCString result((first_capital ? "׷" : "׷"));
01283       if (!singular)  result+="";
01284       return result; 
01285     }
01286 
01291     virtual QCString trPage(bool first_capital, bool singular)
01292     { 
01293       QCString result((first_capital ? "" : ""));
01294       if (!singular)  result+="";
01295       return result; 
01296     }
01297 
01302     virtual QCString trMember(bool first_capital, bool singular)
01303     { 
01304       QCString result((first_capital ? "" : ""));
01305       if (!singular)  result+="";
01306       return result; 
01307     }
01308    
01313     virtual QCString trGlobal(bool first_capital, bool singular)
01314     { 
01315       QCString result((first_capital ? "" : ""));
01316       if (!singular)  result+="";
01317       return result; 
01318     }
01319 
01321 // new since 1.2.7
01323 
01326     virtual QCString trAuthor(bool first_capital, bool singular)
01327     {                                                                         
01328       QCString result((first_capital ? "ۼ" : "ۼ"));
01329       if (!singular)  result+="";
01330       return result; 
01331     }
01332 
01334 // new since 1.2.11
01336 
01339     virtual QCString trReferences()
01340     {
01341       return "  : ";
01342     }
01343 
01345 // new since 1.2.13
01347 
01351     virtual QCString trImplementedFromList(int numEntries)
01352     {
01353       return trWriteList(numEntries)+" .";
01354     }
01355 
01359     virtual QCString trImplementedInList(int numEntries)
01360     {
01361       return trWriteList(numEntries)+" Ǿϴ.";
01362     }
01363 
01365 // new since 1.2.16
01367 
01371     virtual QCString trRTFTableOfContents()
01372     {
01373       return "";
01374     }
01375 
01377 // new since 1.2.17
01379 
01383     virtual QCString trDeprecatedList()
01384     {
01385       return "߸ ڵ ";
01386     }
01387 
01389 // new since 1.2.18
01391 
01395     virtual QCString trEvents()
01396     {
01397       return "̺Ʈ";
01398     }
01400     virtual QCString trEventDocumentation()
01401     {
01402       return "̺Ʈ ȭ";
01403     }
01404 
01406 // new since 1.3
01408 
01411     virtual QCString trPackageTypes()
01412     { 
01413       return "Ű Ÿ";
01414     }
01418     virtual QCString trPackageMembers()
01419     { 
01420       return "Ű Լ";
01421     }
01425     virtual QCString trStaticPackageMembers()
01426     { 
01427       return " Ű Լ";
01428     }
01432     virtual QCString trPackageAttribs()
01433     { 
01434       return "Ű Ӽ";
01435     }
01439     virtual QCString trStaticPackageAttribs()
01440     { 
01441       return " Ű Ӽ";
01442     }
01443     
01445 // new since 1.3.1
01447 
01451     virtual QCString trAll()
01452     {
01453       return "";
01454     }
01456     virtual QCString trCallGraph()
01457     {
01458       return " Լ ο ȣϴ Լ鿡  ׷Դϴ.:";
01459     }
01460 
01462 // new since 1.3.3
01464 
01469     virtual QCString trSearchForIndex()
01470     {
01471       return "˻";
01472     }
01476     virtual QCString trSearchResultsTitle()
01477     {
01478       return "˻ ";
01479     }
01488     virtual QCString trSearchResults(int numDocuments)
01489     {
01490       if (numDocuments==0)
01491       {
01492         return "˼մϴ. ǿ ġϴ  ϴ.";
01493       }
01494       else if (numDocuments==1)
01495       {
01496         return "ǿ ġϴ <b>1</b>   ãҽϴ.";
01497       }
01498       else 
01499       {
01500         return "ǿ ġϴ <b>$num</b>   ãҽϴ. "
01501                "  ġϴ    ݴϴ.";
01502       }
01503     }
01507     virtual QCString trSearchMatches()
01508     {
01509       return ":";
01510     }
01511 
01513 // new since 1.3.8
01515 
01518     virtual QCString trSourceFile(QCString& filename)
01519     {
01520       return filename + " ҽ ";
01521     }
01522 
01524 // new since 1.3.9
01526 
01530     virtual QCString trDirIndex()
01531     { return "丮 뵵"; }
01532 
01536     virtual QCString trDirDocumentation()
01537     { return "丮 ȭ"; }
01538 
01542     virtual QCString trDirectories()
01543     { return "丮"; }
01544 
01548     virtual QCString trDirDescription()
01549     { return " 丮   , (뷫) ĺ ĵǾֽϴ.:";
01550     }
01551 
01555     virtual QCString trDirReference(const char *dirName)
01556     { QCString result=dirName; result+=" 丮 "; return result; }
01557 
01561     virtual QCString trDir(bool first_capital, bool singular)
01562     { 
01563       QCString result((first_capital ? "丮" : "丮"));
01564       if (singular) result+=""; else result+="";
01565       return result; 
01566     }
01567 
01569 // new since 1.4.1
01571 
01575     virtual QCString trOverloadText()
01576     {
01577        return " Լ Ǹ ϱ  ε  ԼԴϴ. "
01578               " Լ Ʋ   ޾Ƶ̴ ƱԸƮ(argument) ٸٴ Դϴ.";
01579     }
01580 
01582 // new since 1.4.6
01584 
01586     virtual QCString trCallerGraph()
01587     {
01588       return " Լ ȣϴ Լ鿡  ׷Դϴ.:";
01589     }
01590 
01594     virtual QCString trEnumerationValueDocumentation()
01595     { return " ȭ"; }
01596 
01598 // new since 1.5.4 (mainly for Fortran)
01600     
01602     virtual QCString trMemberFunctionDocumentationFortran()
01603     { return " Լ/ƾ ȭ"; }
01604 
01606     virtual QCString trCompoundListFortran()
01607     { return "Ÿ Ÿ "; }
01608 
01610     virtual QCString trCompoundMembersFortran()
01611     { return "Ÿ ʵ"; }
01612 
01614     virtual QCString trCompoundListDescriptionFortran()
01615     { return "뷫  Բ Ÿ ŸԵ Դϴ.:"; }
01616 
01618     virtual QCString trCompoundMembersDescriptionFortran(bool extractAll)
01619     {
01620       QCString result=" ";
01621       if (!extractAll)
01622       {
01623         result+="ȭ ";
01624       }
01625       result+=" Ÿ Ÿ  Դϴ. ";
01626 
01627       result+=" ׸ ";
01628       if (!extractAll) 
01629       {
01630          result+="   Ÿ  ȭ  ũ  ֽϴ.";
01631       }
01632       else 
01633       {
01634          result+="׵  Ÿ Ÿ ũ  ֽϴ. :";
01635       }
01636       return result;
01637     }
01638 
01642     virtual QCString trCompoundIndexFortran()
01643     { return "Ÿ Ÿ "; }
01644 
01648     virtual QCString trTypeDocumentation()
01649     { return "Ÿ Ÿ ȭ"; }
01650 
01654     virtual QCString trSubprograms()
01655     { return "Լ/ƾ"; }
01656 
01660     virtual QCString trSubprogramDocumentation()
01661     { return "Լ/ƾ ȭ"; }
01662 
01666      virtual QCString trDataTypes()
01667     { return "Ÿ ŸԵ"; }
01668     
01670     virtual QCString trModulesList()
01671     { return " "; }
01672 
01674     virtual QCString trModulesListDescription(bool extractAll)
01675     {
01676       QCString result=" ";
01677       if (!extractAll) result+="ȭ ";
01678       result+=" ⿡  Դϴ. (  ݴϴ) :";
01679       return result;
01680     }
01681 
01683     virtual QCString trCompoundReferenceFortran(const char *clName,
01684                                     ClassDef::CompoundType compType,
01685                                     bool isTemplate)
01686     {
01687       QCString result=(QCString)clName;
01688       switch(compType)
01689       {
01690         case ClassDef::Class:      result+=" "; break;
01691         case ClassDef::Struct:     result+=" Ÿ"; break;
01692         case ClassDef::Union:      result+=" ü"; break;
01693         case ClassDef::Interface:  result+=" ̽"; break;
01694         case ClassDef::Protocol:   result+=" "; break;
01695         case ClassDef::Category:   result+=" īװ"; break;
01696         case ClassDef::Exception:  result+=" "; break;
01697       }
01698       if (isTemplate) result+=" ø";
01699       result+=" ";
01700       return result;
01701     }
01703     virtual QCString trModuleReference(const char *namespaceName)
01704     {
01705       QCString result=namespaceName;
01706       result+="  ";        
01707       return result;
01708     }
01709     
01711     virtual QCString trModulesMembers()
01712     { return " "; }
01713 
01715     virtual QCString trModulesMemberDescription(bool extractAll)
01716     { 
01717       QCString result=" ";
01718       if (!extractAll) result+="ȭ ";
01719       result+="   Դϴ. ";
01720       if (extractAll) 
01721       {
01722         result+=" ׸    ȭ  ũ  ֽϴ. :";
01723       }
01724       else 
01725       {
01726         result+=" ׸ ׵   ũ  ֽϴ. :";
01727       }
01728       return result;
01729     }
01730 
01734     virtual QCString trModulesIndex()
01735     { return " "; }
01736     
01741     virtual QCString trModule(bool first_capital, bool singular)
01742     {       
01743       QCString result((first_capital ? "" : ""));
01744       if (!singular)  result+="";
01745       return result; 
01746     }
01750     virtual QCString trGeneratedFromFilesFortran(ClassDef::CompoundType compType,
01751         bool single)
01752     { // here s is one of " Module", " Struct" or " Union"
01753       // single is true implies a single file
01754       QCString result=(QCString)" ";
01755       if (single) result+=""; else result+="";
01756       result+="κ  ";
01757       result+=" ";
01758       switch(compType)
01759       {
01760         case ClassDef::Class:      result+=""; break;
01761         case ClassDef::Struct:     result+="Ÿ"; break;
01762         case ClassDef::Union:      result+="ü"; break;
01763         case ClassDef::Interface:  result+="̽"; break;
01764         case ClassDef::Protocol:   result+=""; break;
01765         case ClassDef::Category:   result+="īװ"; break;
01766         case ClassDef::Exception:  result+=""; break;
01767       }
01768       result+=" ȭ :";
01769       return result;
01770     }
01775     virtual QCString trType(bool first_capital, bool singular)
01776     { 
01777       QCString result((first_capital ? "Ÿ" : "Ÿ"));
01778       if (!singular)  result+="";
01779       return result; 
01780     }
01785     virtual QCString trSubprogram(bool first_capital, bool singular)
01786     { 
01787       QCString result((first_capital ? "α׷" : "α׷"));
01788       if (!singular)  result+="";
01789       return result; 
01790     }
01791 
01793     virtual QCString trTypeConstraints()
01794     {
01795       return "Ÿ ڵ";
01796     }
01797 
01798 };
01799 
01800 #endif



Generated on Mon Mar 31 10:58:46 2008 by  doxygen 1.5.1