🧚🏽 👆🏼 📝 स्टूडियो कैच की कार्यक्षमता को बढ़ाने का एक और तरीका 🧑🏿‍🤝‍🧑🏾 🔄 😺

मुझे इस राय के साथ मिलना था कि कैच स्टूडियो बिल्कुल सही नहीं है, विशेष रूप से यह कि इसका विस्तार नहीं किया जा सकता है। हालाँकि, यह पूरी तरह सच नहीं है। टेम्पलेट्स और एक्सटेंशन का एक पूर्णकालिक तंत्र है, जो आपको इंटरैक्टिव ऐड-ऑन के साथ स्टूडियो को पूरा करने की अनुमति देता है।
इस लेख में, हम एक अन्य एक्सटेंशन विधि पर स्पर्श करेंगे जो आपके कोड को अधिक कुशलता से प्रबंधित करने में आपकी सहायता कर सकती है। यह संस्करण नियंत्रण प्रणाली के साथ स्टूडियो एकीकरण वर्ग में मदद करेगा।
संस्करण नियंत्रण वर्ग के साथ क्या किया जा सकता है? सबसे पहले, स्टूडियो में होने वाली कुछ घटनाओं को ट्रैक करने के लिए, जैसे कनेक्ट करना, बनाना, हटाना, दस्तावेज़ खोलना और दूसरा, मेनू में आइटम जोड़ने की क्षमता, संदर्भ मेनू सहित। इन मेनू आइटमों के माध्यम से, आप न केवल सर्वर पर कोड निष्पादित कर सकते हैं, बल्कि कुछ सरल संवाद भी बना सकते हैं।

आइए, इंडेंट को कम करने / बढ़ाने, कोड के ब्लॉक को कम करने / अनसुना करने के लिए स्टूडियो मेनू का विस्तार करने की कोशिश करें (ये फीचर कीबोर्ड शॉर्टकट्स के कैच के नवीनतम संस्करणों में उपलब्ध हैं), और इंडेंट और ब्रैकेट्स को पुन: स्वरूपित करने की क्षमता भी जोड़ते हैं, जो अक्सर बड़े संपादन के समय पर्याप्त नहीं होता है कार्यक्रम।

एक संस्करण नियंत्रण वर्ग बनाना

चलिए Util.StudioExtension वर्ग को% Studio.Extension.Base के उत्तराधिकारी के रूप में बनाते हैं और इसे सर्वर कॉन्फ़िगरेशन में उस क्षेत्र के लिए लिखते हैं जिसमें हम इस एक्सटेंशन का उपयोग करने जा रहे हैं:

सिस्टम प्रशासन> कॉन्फ़िगरेशन> उन्नत सेटिंग्स -> संस्करण नियंत्रण प्रणाली

कक्षा Util.StudioExtension% Studio.Extension.Base का विस्तार करता है
{
XData मेनू
{
< मेनूबेस >
< मेनू का नाम = "प्रारूप" प्रकार = "1" >
< MenuItem नाम = "PlusTab" />
< MenuItem नाम = "MinusTab" />
< MenuItem सेपरेटर = "1" />
< MenuItem नाम = "सुधारना" />
< MenuItem नाम = "सुधारक कार्य" " सहेजें = " 100 " />
< MenuItem सेपरेटर = "1" />
< MenuItem नाम = "CommentBlock" />
< MenuItem नाम = "UnCommentBlock" />
</ मेनू >
</ MenuBase >
}
}
इस ब्लॉक में, MenuBase, Menu, MenuItem टैग% Studio.Extension.Base,% Studio.Extension.Menu,% Studio.Extension.MenuItem वर्गों की मैपिंग हैं, विशेषताओं के अर्थ को उनके प्रलेखन से समझा जा सकता है। हमारे मामले में, नाम आइटम का आंतरिक नाम है, टाइप = 1 का अर्थ है कि मेनू प्रासंगिक है, सेपरेटर = 1, कि आइटम एक विभाजक है, सहेजें = 100, कि जब आप मेनू आइटम पर क्लिक करते हैं, तो दस्तावेज़ को सहेजा जाना चाहिए।

एक ऐसी विधि बनाएं जो मेनू के प्रदर्शन को स्वयं संभालती है। मेनू आइटम में पठनीय रूसी नाम जोड़ें, उन मामलों में जहां हम इसे आवश्यक मानते हैं, उन्हें निष्क्रिय करें (सक्षम = 0)। उदाहरण के लिए, यह विकल्प "सुधारित चयनित पाठ" को सक्रिय बनाने के लिए कोई मतलब नहीं है, अगर कुछ भी नहीं चुना गया है।

OnMenuItem विधि

विधि OnMenuItem ( मेनू नाम % स्ट्रिंग के रूप में , आंतरिक नाम % स्ट्रिंग , चयनित स्ट्रिंग के रूप में% स्ट्रिंग , ByRef % बुलियन के रूप में सक्षम ,
% स्थिति के रूप में ByRef DisplayName ) % स्थिति के रूप में
{
सेट : MenuName = "फ़ॉर्मेट" DisplayName = "फ़ॉर्मेट"
सेट : MenuName = "प्रारूप, प्लसटैब" DisplayName = "-> | इंडेंटेशन बढ़ाएँ"
सेट : मेनूनाम = "प्रारूप, माइनसटैब" डिस्प्लेनाम = "। <- इंडेंटेशन कम करें"
सेट : MenuName = "प्रारूप, रिफॉर्मडडिमेमेंट " DisplayName = "दस्तावेज़ रिफॉर्म करें"
सेट करें : मेनूनाम = "प्रारूप, सुधार सत्र " प्रदर्शननाम = "सुधार चयन"
सेट : MenuName = "प्रारूप, टिप्पणी करें" DisplayName = "टिप्पणी ब्लॉक"
सेट करें : MenuName = "प्रारूप, UnCommentBlock" DisplayName = "ब्लॉक को रद्द करें"
सेट सक्षम = 1
सेट ext = $ टुकड़ा ( आंतरिक नाम " , " , $ लंबाई ( आंतरिक नाम , "" ))।
सेट करें :( मेनूनाम = "प्रारूप, सुधारक कार्य" ) और& ( ext '= "MAC" ) और& ( ext ' = "CLS" ) सक्षम = 0
सेट :( MenuName = "प्रारूप, रिफॉर्मैटेशन " ) && ( चयनितटाइप = "" ) अक्षम ) 0
सेट :( मेनूनाम = "प्रारूप, माइनसटैब" ) और& ( चयनितटाइप = "" ) सक्षम = 0
सेट करें :( MenuName = "प्रारूप, UnCommentBlock" ) && ( चयनितटाइप = "" ) सक्षम = 0
1 छोड़ दिया
}

पुन: कनेक्ट करने के बाद, एक नया संदर्भ मेनू आइटम दिखाई देना चाहिए, लेकिन यह अभी भी कुछ नहीं करता है:

इंडेंट क्लास सी

एक UserAction विधि बनाएँ जो विभिन्न कार्यों पर प्रतिक्रिया देगा, जिसमें मेनू आइटम की पसंद शामिल है:

उपयोगकर्ता विधि

/ * कुछ हुआ
प्रकार = 0 - मेनू आइटम दबाया जाता है,
इस स्थिति में, आंतरिक नाम मेनू आइटम का नाम है, जबकि
आंतरिक नाम - दस्तावेज़ का नाम,
चयनित पाठ - चयनित पाठ (यदि चयनित है)

प्रकार = 1 - घटना स्वचालित रूप से बनाई गई थी, जबकि
नाम = 0 - उपयोगकर्ता ने दस्तावेज़ को बदल दिया है
नाम = 1 - एक नया दस्तावेज़ बनाया और बचाया
नाम = 2 - उपयोगकर्ता ने दस्तावेज़ को हटा दिया
नाम = 3 - उपयोगकर्ता ने दस्तावेज़ खोला
नाम = 4 - उपयोगकर्ता ने दस्तावेज़ को बंद कर दिया
नाम = 5 - उपयोगकर्ता जुड़ा हुआ है
आंतरिक नाम - दस्तावेज़ का नाम जिसके साथ घटना हुई

स्टूडियो की कार्रवाई को इंगित करने के लिए क्रिया का उपयोग किया जाता है।
० - कुछ मत करो
1 - मानक संवाद हाँ / नहीं / रद्द करें दिखाएं। संवाद का पाठ लक्ष्य चर में निर्दिष्ट किया गया है।
2 - csp पेज लॉन्च करें। लक्ष्य पृष्ठ का नाम इंगित करता है
3 - क्लाइंट पर EXE फ़ाइल चलाएँ। लक्ष्य फ़ाइल पथ इंगित करता है
4 - दस्तावेज़ में वर्तमान स्थिति में लक्ष्य चर में निहित पाठ डालें
5 - लक्ष्य चर में निहित दस्तावेज़ खोलें। दस्तावेजों की सूची को अल्पविराम द्वारा अलग किया जाता है। यदि दस्तावेज़ नाम में 'test.mac: लेबल + 10' है, तो test.mac दस्तावेज़ 'लेबल + 10' की स्थिति में खुलेगा।
6 - लक्ष्य चर में निहित संदेश के साथ एक विंडो प्रदर्शित करें
7 - हां / नहीं / रद्द करें विकल्पों के साथ एक संवाद प्रदर्शित करता है। संवाद का पाठ लक्ष्य चर में निहित है। संदेश परीक्षण चर Msg में पास किया गया है।
यदि रीलोड तर्क सत्य है, तो वर्तमान दस्तावेज़ पुनः लोड किया जाएगा।
* /
विधि उपयोगकर्ता प्रकार ( %% पूर्णांक के रूप में,% स्ट्रिंग के रूप में नाम , आंतरिक नाम % स्ट्रिंग के रूप में , चयनित शीर्ष क्रम स्ट्रिंग के रूप में ,
% स्ट्रिंग के रूप में ByRef क्रिया , % String के रूप में ByRef लक्ष्य , % String द्वारा ByRef Msg , % Boolean के रूप में ByRef पुनः लोड ) % स्थिति के रूप में
{
सेट ext = $ zconvert ( $ टुकड़ा ( InternalName , " , " , $ लंबाई ( आंतरिक नाम , "" )), "U" )।
यदि नाम = "प्रारूप, प्लसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। प्लसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
अगर नाम = "प्रारूप, माइनसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। माइनसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
1 छोड़ दिया
}

वह वर्ग जो हम टैब को प्रारूपित करने के लिए उपयोग करते हैं:

Util.FormatTab क्लास

/// पाठ में टैब के साथ काम करने के लिए कक्षा
क्लास यूटिल.फॉर्मटैब
{
/// आरंभ करने वाली सभी पंक्तियों की शुरुआत में टैब जोड़ें
/// एक स्थान या टैब के साथ।
/// पाठ चिह्नित के लिए
ClassMethod PlusTab ( टेक्स्ट स्ट्रिंग% के रूप में , inCsp % Boolean = 0 ) % स्ट्रिंग के रूप में
{
सेट cr = $ char (13,10) ; लाइन फ़ीड अक्षर
सेट टैब = $ char (9) ; टैब वर्ण
सेट स्ट्रिंग्सइन = $ लिस्टफ्रॉमस्ट्रिंग ( पाठ , करोड़ )
सेट स्ट्रिंग्सओट = ""
मैं = 1: 1: $ सूची ( तार )
{
सेट लाइन = $ सूची ( स्ट्रिंग्सइन , i )
प्रथम सेट = $ अर्क ( पंक्ति , 1,1)
if ( inCsp = 1) || ( फर्स्टसिमबोल = "" ) || ( फर्स्टसंबोल = टैब )
{
पद के लिए = 1: 1: $ लंबाई ( लाइन ) ; पहले गैर-व्हाट्सएप चरित्र की स्थिति की तलाश
{
सेट प्रतीक = $ अर्क ( लाइन , पॉज़ , पॉज़ )
छोड़ दिया :( प्रतीक '= "" ) और& ( प्रतीक ' = टैब )
}
सेट लाइन = $ एक्सट्रेक्ट ( लाइन , 1, पॉस -1) _ टैब _ $ एक्सट्रेक्ट ( लाइन , पॉज़ , *)
}
सेट स्ट्रिंग्सओट = स्ट्रिंग्सऑट _ $ सूची ( लाइन )
}
$ listtostring ( stringsOut , cr ) को छोड़ दें
}
/// पंक्ति की शुरुआत में टैब हटाएं
/// टेक्स्ट - जिस टेक्स्ट को हम प्रोसेस कर रहे हैं
/// inCsp - एक संकेत है कि हम एक csp पृष्ठ के साथ काम कर रहे हैं,
/// लाइन की शुरुआत में एक स्थान को मजबूर करने की कोशिश नहीं कर रहा है
क्लासमैथोड माइनसटैब ( पाठ स्ट्रिंग के रूप में,% बुलियन के रूप में inCsp = 0 )
{
सेट cr = $ char (13,10) ; लाइन फ़ीड अक्षर
सेट टैब = $ char (9) ; टैब वर्ण
टैब सेट करें = 4
सेट स्ट्रिंग्सइन = $ लिस्टफ्रॉमस्ट्रिंग ( पाठ , करोड़ )
सेट स्ट्रिंग्सओट = ""
मैं = 1: 1: $ सूची ( तार )
{
सेट लाइन = $ सूची ( स्ट्रिंग्सइन , i )
प्रथम सेट = $ अर्क ( पंक्ति , 1,1)
j = 1: 1: tabSize के लिए
{
सेट प्रतीक = $ अर्क ( लाइन , 1,1)
अगर प्रतीक = ""; पहले 4 रिक्त स्थान निकालें
{
सेट लाइन = $ अर्क ( लाइन , 2, *)
}
और प्रतीक = टैब ; हम टैब निकालते हैं, और हम यहां समाप्त होते हैं
{
सेट लाइन = $ अर्क ( लाइन , 2, *)
छोड़ना
}
और ; कोई स्थान और कोई टैब नहीं, रिक्त स्थान निकालना
{
छोड़ना
}
}
; और अचानक सभी रिक्त स्थान को हटा दिया, और वाक्यविन्यास के संदर्भ में लाइन गलत हो गई
; यह निश्चित रूप से होगा यदि यह एक csp दस्तावेज़ नहीं है
if ( inCsp = 0) && (( firstSymbol = "" ) || (( firstSymbol = tab )) && ( $ extract ( पंक्ति , 1,1) '= "" ) और& ( $ extract ( पंक्ति , 1,1)') = टैब )
{
सेट लाइन = "" _ लाइन
}
सेट स्ट्रिंग्सओट = स्ट्रिंग्सऑट _ $ सूची ( लाइन )
}
$ listtostring ( stringsOut , cr ) को छोड़ दें
}
}

अब, यदि आप स्टूडियो के साथ फिर से कनेक्ट करते हैं (यह हमेशा संस्करण नियंत्रण वर्ग को बदलने के बाद किया जाना चाहिए), मेनू आइटम "इंडेंटेशन जोड़ें" और "इंडेंटेशन निकालें" काम करना चाहिए।

टिप्पणी करने / कोड करने के लिए कक्षा

हम Util.StudioExtension वर्ग के उपयोगकर्ताएशन विधि को संशोधित करते हैं, नई वस्तुओं के लिए प्रसंस्करण जोड़ते हैं:

उपयोगकर्ता विधि

विधि उपयोगकर्ता प्रकार ( %% पूर्णांक के रूप में,% स्ट्रिंग के रूप में नाम , आंतरिक नाम % स्ट्रिंग के रूप में , चयनित शीर्ष क्रम स्ट्रिंग के रूप में ,
% स्ट्रिंग के रूप में ByRef क्रिया , % String के रूप में ByRef लक्ष्य , % String द्वारा ByRef Msg , % Boolean के रूप में ByRef पुनः लोड ) % स्थिति के रूप में
{
सेट ext = $ zconvert ( $ टुकड़ा ( InternalName , " , " , $ लंबाई ( आंतरिक नाम , "" )), "U" )।
सेट डॉकनामे = $ अर्क ( इंटरनलनेम , 1, * - 4)
यदि नाम = "प्रारूप, प्लसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। प्लसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
अगर नाम = "प्रारूप, माइनसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। माइनसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
अगर नाम = "प्रारूप, टिप्पणी करें"
{
सेट क्रिया = 4
s लक्ष्य = ## वर्ग ( Util.FormatComment )। AddComment ( चयनितटैक्स )
}
अगर नाम = "प्रारूप, अनब्लॉकब्लॉक"
{
सेट क्रिया = 4
s लक्ष्य = ## वर्ग ( Util.FormatComment )। RemoveComment ( चयनितटैक्स )
}
1 छोड़ दिया
}

हम तार को संसाधित करने के लिए Util.FormatComment वर्ग का उपयोग करते हैं:

Util.FormatComment वर्ग

/// क्लास कमेंटिंग / अनकम्प्लीमेंट कोड के लिए
कक्षा Util.FormatComment
{
/// प्रत्येक पंक्ति की शुरुआत में एक टिप्पणी जोड़ें
/// एक स्थान या टैब के साथ।
/// पाठ चिह्नित के लिए
ClassMethod AddComment ( टेक्स्ट स्ट्रिंग % के रूप में ) % स्ट्रिंग के रूप में
{
सेट cr = $ char (13,10) ; लाइन फ़ीड अक्षर
सेट स्ट्रिंग्सइन = $ लिस्टफ्रॉमस्ट्रिंग ( पाठ , करोड़ )
सेट स्ट्रिंग्सओट = ""
सेट स्ट्रिंग्सकाउंट = $ सूची ( स्ट्रिंग्स )
मैं = 1: 1: $ सूची ( तार )
{
सेट लाइन = $ सूची ( स्ट्रिंग्सइन , i )
s :( i < stringsCount ) || ( पंक्ति '= "" ) रेखा = "//" _ पंक्ति ? पाठ के एक ब्लॉक की नकल करते समय, एक अतिरिक्त पंक्ति फ़ीड अक्सर पकड़ा जाता है;
सेट स्ट्रिंग्सओट = स्ट्रिंग्सऑट _ $ सूची ( लाइन )
}
डब्ल्यू । ;; , $ लिस्टट्रोस्टिंग ( स्ट्रिंग्सऑट , करोड़ )
$ listtostring ( stringsOut , cr ) को छोड़ दें
}
/// पंक्ति की शुरुआत से टिप्पणियां हटाएं
ClassMethod RemoveComment ( पाठ स्ट्रिंग के रूप में )
{
सेट cr = $ char (13,10) ; लाइन फ़ीड चरित्र
सेट टैब = $ char (9) ; टैब वर्ण
सेट स्ट्रिंग्सइन = $ लिस्टफ्रॉमस्ट्रिंग ( पाठ , करोड़ )
सेट स्ट्रिंग्सओट = ""
मैं = 1: 1: $ सूची ( तार )
{
सेट लाइन = $ सूची ( स्ट्रिंग्सइन , i )
; यह निर्धारित करने के लिए कि क्या इस पंक्ति पर कोई टिप्पणी है, अग्रणी स्थान और टैब निकालें
सेट लाइन 0 = $ अनुवाद ( लाइन , "" _ टैब , "" )
अगर $ अर्क ( लाइन 0 , 1,1) = ";"
{
सेट पोज़ = $ ढूंढें ( पंक्ति , ";" )
सेट लाइन = $ अर्क ( लाइन , 1, पॉस -2) _ $ एक्सट्रेक्ट ( लाइन , पॉज़ , *)
}
और $ $ निकालने ( लाइन 0 , 1,3) = "///"
{
सेट पोज़ = $ खोजें ( पंक्ति , "///" )
सेट लाइन = $ अर्क ( लाइन , 1, पॉस -4) _ $ अर्क ( लाइन , पॉज़ , *)
}
$ $ अर्क ( लाइन 0 , 1,2) = "//"
{
सेट पोज़ = $ खोजें ( पंक्ति , "//" )
सेट लाइन = $ अर्क ( लाइन , 1, पॉज़ -3) _ $ एक्सट्रेक्ट ( लाइन , पॉज़ , *)
}
सेट स्ट्रिंग्सओट = स्ट्रिंग्सऑट _ $ सूची ( लाइन )
}
$ listtostring ( stringsOut , cr ) को छोड़ दें
}
/// इस बारे में जानकारी लौटाता है कि क्या लाइन में टिप्पणी की गई है।
/// केवल एकल-पंक्ति टिप्पणियों को समझता है
ClassMethod CheckForComment ( पाठ स्ट्रिंग % के रूप में ) % बूलियन के रूप में
{
सेट cr = $ char (13,10) ; लाइन फ़ीड चरित्र
सेट टैब = $ char (9) ; टैब वर्ण
सेट स्ट्रिंग्सइन = $ लिस्टफ्रॉमस्ट्रिंग ( पाठ , करोड़ )
सेट स्ट्रिंग्सओट = ""
मैं = 1: 1: $ सूची ( तार )
{
सेट लाइन = $ सूची ( स्ट्रिंग्सइन , i )
सेट लाइन = $ अनुवाद ( लाइन , "" _ टैब , "" )
वापसी : $ ई ( लाइन , 1,2) = "//" 1
वापसी : $ e ( पंक्ति , 1,1) = ";" 1
}
0 छोड़ दिया
}
}

पाठ स्वरूपण

कोड को पुन: स्वरूपित करने के लिए वर्ग से कनेक्ट करें। यह उपयोगी हो सकता है यदि आपकी परियोजना विभिन्न टीमों या प्रोग्रामर द्वारा लिखी गई थी जो एक ही शैली का पालन नहीं करते थे। कोड टाइप करें
के लिए मैं = TheNum : 1: TheNum +2 {
सेट स्टार्टटाइम = 12 * 3600 + (300 * $ आर (6))
जबकि StartTime <(3600 * 22) {
सेट शो = ## वर्ग ( Cinema.Show )। % नया ()
शो का सेट । फिल्म = द फ़िल्म
शो का सेट । रंगमंच = ( i )
शो का सेट । StartTime = StartTime
दिखाओ % बचाओ ()
StartTime = StartTime + ( TheFilm । लंबाई * 60) + 1200 \ 300 * 300 निर्धारित करें
}
}
में बदल सकते हैं
के लिए मैं = TheNum : 1: TheNum +2
{
सेट स्टार्टटाइम = 12 * 3600 + (300 * $ आर (6))
जबकि StartTime <(3600 * 22)
{
सेट शो = ## वर्ग ( Cinema.Show )। % नया ()
शो का सेट । फिल्म = द फ़िल्म
शो का सेट । रंगमंच = ( i )
शो का सेट । StartTime = StartTime
दिखाओ % बचाओ ()
StartTime = StartTime + ( TheFilm । लंबाई * 60) + 1200 \ 300 * 300 निर्धारित करें
}
}
या इसके विपरीत, आप की तरह। "ब्रैकेट पर ब्रैकेट" शैली के लिए क्लास यूटिल है। कोडफ़ॉर्मैट, "लाइन के अंत में ब्रैकेट" शैली के लिए क्लास यूटिल है। कोडकोडर्मैट 3

हम नए मेनू आइटमों के लिए प्रोसेसिंग जोड़कर UserAction विधि को संशोधित करते हैं:

उपयोगकर्ता विधि

विधि यूजरएशन ( प्रकार % पूर्णांक के रूप में , नाम % स्ट्रिंग के रूप में , आंतरिक नाम % स्ट्रिंग के रूप में , चयनित स्ट्रिंग के रूप में% स्ट्रिंग , ByRef कार्रवाई % स्ट्रिंग के रूप में ,
% स्ट्रिंग के रूप में ByRef लक्ष्य , % String ByRef Msg , % स्थिति के रूप में ByRef पुनः लोड करें )
{
सेट ext = $ zconvert ( $ टुकड़ा ( InternalName , " , " , $ लंबाई ( आंतरिक नाम , "" )), "U" )।
सेट डॉकनामे = $ अर्क ( इंटरनलनेम , 1, * - 4)
यदि नाम = "प्रारूप, प्लसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। प्लसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
अगर नाम = "प्रारूप, माइनसटैब"
{
सेट क्रिया = 4 ; पाठ प्रविष्टि
सेट लक्ष्य = ## वर्ग ( Util.FormatTab )। माइनसटैब ( चयनितटेक्स्ट , एक्सट = "सीएसपी" )
}
अगर नाम = "प्रारूप, टिप्पणी करें"
{
सेट क्रिया = 4
सेट लक्ष्य = ## वर्ग ( Util.FormatComment )। AddComment ( चयनितटैक्स )
}
अगर नाम = "प्रारूप, अनब्लॉकब्लॉक"
{
सेट क्रिया = 4
सेट लक्ष्य = ## वर्ग ( Util.FormatComment )। RemoveComment ( चयनितटैक्स )
}
अगर नाम = "प्रारूप, सुधार
{
सेट क्रिया = 4
सेट लक्ष्य = ## वर्ग ( Util.CodeFormat )। FormatString ( चयनित टेक्स्ट )
}
अगर नाम = "प्रारूप, सुधार
{
सेट क्रिया = ०
do : ext = "MAC" ## वर्ग ( Util.CodeFormat )। FormatMAC ( docname )
do : ext = "CLS" ## वर्ग ( Util.CodeFormat )। FormatClass ( docname )
}
1 छोड़ दिया
}

"कोष्ठक से अधिक कोष्ठक" की शैली में क्लास हैंडलर कोड

कक्षा Util.CodeFormat

/// कोड फॉर्मेटर क्लास
कक्षा Util.CodeFormat% RegisteredObject का विस्तार करता है
{
/// इनपुट बफर ग्लोबल नाम
संपत्ति बफर 1% स्ट्रिंग के रूप में ;

/// वैश्विक आउटपुट बफर का नाम
संपत्ति बफर 2 % स्ट्रिंग के रूप में ;

/// इनपुट बफर की करंट लाइन
संपत्ति CurrentLine1 % संख्यात्मक के रूप में [ InitialExpression = 1 ];

/// आउटपुट बफर की करंट लाइन
संपत्ति CurrentLine2 % संख्यात्मक के रूप में [ InitialExpression = 1 ];

/// इनपुट बफर लाइन में वर्तमान स्थिति
संपत्ति CurrentPos1 % संख्यात्मक के रूप में [ InitialExpression = 1 ];

/// घुंघराले कोष्ठक का स्तर
प्रॉपर्टी LevelFigureBrace % Integer [ InitialExpression = 0 ] के रूप में;

/// कोष्ठक स्तर
प्रॉपर्टी LevelRoundBrace % पूर्णांक [ प्रारंभिकExpression = 0 ] के रूप में;

/// क्या लाइन पर कोई कोड है? 
/// संयोजन:
/// LineHasCode = 0 && स्किपस्पेस = 1 -> लाइन की शुरुआत, एक लेबल या कोड की अपेक्षा करें
/// LineHasCode = 0 && स्किपस्पेस = 0 -> ऐसा नहीं होना चाहिए
/// LineHasCode = 1 && SkipSpace = 0 -> पहले से ही कोड है, जैसा है वैसा ही सब कुछ लिखें
/// LineHasCode = 1 && SkipSpace = 1 -> पहले से ही कोड है, लेकिन रिक्त स्थान छोड़ें, उदाहरण के लिए, {के बाद
प्रॉपर्टी लाइनहासकोड % बूलियन के रूप में ;

/// रिक्त स्थान छोड़ें
प्रॉपर्टी स्किपस्पेस के रूप में% बूलियन [ InitialExpression = 1 ];

/// लाइन फीड को छोड़ें
/// 1 - एक को छोड़ दें
/// -1 - अनुवाद को अभी छोड़ दिया गया है, आपको टैग और अन्य चीजों के प्रति चौकस रहने की आवश्यकता है
संपत्ति SkipCR % बूलियन के रूप में [ InitialExpression = 0 ];

/// इंडेंटेशन की आवश्यकता है (जब कोड दिखाई दे)
संपत्ति की आवश्यकता % बूलियन के रूप में ;

/// एक एकल पंक्ति टिप्पणी में?
प्रॉपर्टी InSingleLineComment % बूलियन के रूप में [ InitialExpression = 0 ];

/// एक बहु-पंक्ति टिप्पणी में?
संपत्ति InMultiLineComment % बूलियन के रूप में [ InitialExpression = 0 ];

/// प्रक्रिया लाइन फ़ीड
विधि ProcessCR ( % स्ट्रिंग के रूप में पाठ )
{
if .. SkipCR = 1
{
set .. SkipCR = -1
1 छोड़ दिया
}
करते हैं : .. जरूरत है .. लिखें (.. MakeIndent ())
सेट .. लाइनहासकोड = 0
set .. स्किपस्पेस = 1
set .. जरूरतमंद = ०
set .. InSleleLineComment = 0
do .. WriteCR ()
1 छोड़ दिया
}
/// हैंडल व्हाट्सएप
विधि प्रोसेसस्पेस ( पाठ स्ट्रिंग के रूप में )
{
छोड़ दिया :( .. InMultiLineComment ) .. ProcessCononCode ( पाठ )
; लाइन फ़ीड को दबा दिया गया था, यह सफेद जगह के बाद सामान्य चरित्र है।
set : .. SkipCR = -1 .. SkipCR = 0, .. NeedIndent = 0, .. SkipSpace = 1
करें : '.. स्किपस्पेस .. लिखें ( पाठ )
सेट : '.. LineHasCode .. NeedIndent = 1
1 छोड़ दिया
}
/// प्रक्रिया खोलने ब्रेसिज़
विधि ProcessFigureBraceOpen ( % स्ट्रिंग के रूप में पाठ )
{
छोड़ दिया :( .. LevelRoundBrace ) .. ProcessCommonCode ( पाठ )
छोड़ दिया :( .. InMultiLineComment ) .. ProcessCononCode ( पाठ )
छोड़ दिया :( .. InSleleLineComment ) .. ProcessCononCode ( पाठ )
do : .. लाइनहसकोड .. राइटसीआर ()
do .. लिखो (.. MakeIndent () _ text )
do .. WriteCR ()

set .. LevelFigureBrace = .. LevelFigureBrace +1
set .. LineHasCode = 0, .. SkipSpace = 1, .. जरूरत = 1, .. SkipCR = 1
1 छोड़ दिया
}
/// प्रक्रिया बंद ब्रेसिज़
विधि ProcessFigureBraceClose ( पाठ स्ट्रिंग के रूप में )
{
छोड़ दिया :( .. LevelRoundBrace ) .. ProcessCommonCode ( पाठ )
छोड़ दिया :( .. InMultiLineComment ) .. ProcessCononCode ( पाठ )
छोड़ दिया :( .. InSleleLineComment ) .. ProcessCononCode ( पाठ )
छोड़ दिया :( .. LevelFigureBrace = 0) .. ProcessCommonCode ( पाठ )
do : .. लाइनहसकोड .. राइटसीआर ()
set .. LevelFigureBrace = .. LevelFigureBrace -1
do .. लिखो (.. MakeIndent () _ text )
do .. WriteCR ()
set .. SkipCR = 1, .. NeedIndent = 1, .. SkipSpace = 1, .. LineHasCode = 0
1 छोड़ दिया
}
/// प्रक्रिया कोष्ठक खोलने
विधि ProcessRoundBraceOpen ( पाठ स्ट्रिंग के रूप में )
{
सेट :( .. InMultiLineComment = 0) और& (.. InSleleLineComment = 0) .. LevelRoundBrace = .. LevelRoundBrace +1
करो .. लिखो ( पाठ )
1 छोड़ दिया
}
/// प्रक्रिया समापन कोष्ठक
विधि ProcessRoundBraceClose ( पाठ स्ट्रिंग के रूप में )
{
set :( .. InMultiLineComment = 0) और& (.. InSleleLineComment = 0) और& (.. LevelRoundBrace > 0) .. LevelRoundBrace = .. LevelRoundBrace -1
करो .. लिखो ( पाठ )
1 छोड़ दिया
}
/// एक बहु-लाइन टिप्पणी खोलने की प्रक्रिया
विधि ProcessMultilineCommentOpen ( पाठ स्ट्रिंग के रूप में )
{
set .. InMultiLineComment = 1
do .. ProcessCommonCode ( पाठ )
1 छोड़ दिया
}
/// प्रक्रिया बहु-पंक्ति टिप्पणी को बंद करना
विधि ProcessMultilineCommentClose ( % स्ट्रिंग के रूप में पाठ )
{
सेट .. InMultiLineComment = 0
do .. ProcessCommonCode ( पाठ )
1 छोड़ दिया
}
/// एकल पंक्ति टिप्पणी
विधि ProcessOnelineCommentOpen ( पाठ स्ट्रिंग के रूप में )
{
do .. ProcessCommonCode ( पाठ )
set .. InSleleLineComment = 1
1 छोड़ दिया
}
/// बिना किसी फीचर्स के कोड को प्रोसेस करें
विधि ProcessCommonCode ( पाठ स्ट्रिंग के रूप में )
{
// लाइन का अनुवाद किया, और नई लाइन पर तुरंत पाठ - यह लेबल दिखाई दे रहा है।
// आपको इस तथ्य के बावजूद कि अनुवाद को दबाया गया था, सभी को स्ट्रिंग का अनुवाद करने की आवश्यकता है
if .. SkipCR = -1
{
do .. WriteCR ()
set .. जरूरतमंद = ०
}
set .. SkipCR = 0
set : .. नीत पाठ = .. मेकइंडेंट () _ पाठ
करो .. लिखो ( पाठ )
सेट .. स्किपस्पेस = 0
set .. लाइनहासकोड = 1
set .. जरूरतमंद = ०
1 छोड़ दिया
}
/// खसखस प्रोग्राम को रिफॉर्म करें
/// d ## वर्ग (Util.CodeFormat) .FormatMAC ("शीर्षकहीन 1")
ClassMethod FormatMAC ( % स्ट्रिंग के नाम ) % पूर्णांक के रूप में
{
छोड़ दिया : नाम = ""
छोड़ दिया : ' $ डेटा (^ rMAC ( नाम ))
सेट पार्सर = .. % नया ()
पार्सर सेट करें । बफर 1 = "^ || बफर 1"
पार्सर सेट करें । बफर 2 = "^ || बफर 2 "
मार डालो @ पार्सर । Buffer1
मार डालो @ पार्सर । Buffer2
सेट कुंजी = 0, पंक्ति = 0
के लिए // प्रोग्राम ग्लोबल से बफर डेटा को लिखें
{
सेट कुंजी = $ आदेश (^ rMAC ( नाम , 0, कुंजी )) छोड़ दिया : + कुंजी = 0
@ पार्सर सेट करें । बफ़र 1 @ ( $ वेतन वृद्धि ( लाइन )) = ^ rMAC ( नाम , 0, कुंजी )
}
सेट ब्रेसिज़ = पार्सर । फ़ॉर्म बफ़र ()
नाम , नाम , ":" , ब्रेसिज़
सेट कुंजी = 0
के लिए ; पुरानी प्रोग्राम लाइन हटाएं
{
सेट कुंजी = $ आदेश (^ rMAC ( नाम , 0, कुंजी )) छोड़ दिया : + कुंजी = 0
मार ^ rMAC ( नाम , 0, कुंजी )
}
मर्ज ^ rMAC ( नाम , 0) = @ पार्सर । Buffer2
सेट ^ rMAC ( नाम , 0,0) = $ ऑर्डर (@ parser । बफर 2 @ ( "" ), - 1)
सेट ^ rMAC ( नाम , 0) = $ horolog
}
/// सभी वर्ग विधियों को प्रारूपित करें 
/// d ## वर्ग (Util.CodeFormat) .FormatClass ("Import.NIAdvs")
ClassMethod FormatClass ( वर्ग स्ट्रिंग के रूप में )
{
सेट विधि = ""
के लिए
{
सेट विधि = $ ऑर्डर (^ ऑडडेईएफ ( कक्षा , "एम" , विधि )) पद छोड़ना : विधि = ""
do .. FormatMethod ( वर्ग , विधि )
}
}
/// क्लास विधि को प्रारूपित करें। बहुत खूबसूरती से नहीं लिखा - ग्लोबल्स और ऑब्जेक्ट्स का मिश्रण 
/// d ## वर्ग (Util.CodeFormat) .FormatMethod ("Import.NIAdvs", "% OnValidateObject5")
ClassMethod FormatMethod ( वर्ग स्ट्रिंग के रूप में,% स्ट्रिंग के रूप में विधि )
{
सेट mdef = ## वर्ग ( % Dictionary.MethodDefinition )। % OpenId ( वर्ग _ "||" _ विधि )
छोड़ दिया : mdef = ""
सेट gl1 = "^ oddDEF (" "" _ वर्ग _ "" "," "m" "," "" _ विधि _ "" ", 30)"; विधि कोड यहाँ संग्रहीत है
सेट पार्सर = .. % नया ()
पार्सर सेट करें । बफर 1 = "^ || बफर 1"
पार्सर सेट करें । बफर 2 = "^ || बफर 2 "
मार डालो @ पार्सर । Buffer1
मार डालो @ पार्सर । Buffer2

सेट कुंजी = 0
के लिए // वैश्विक विधि से बफर डेटा लिखें
{
सेट कुंजी = $ ऑर्डर (@ gl1 @ ( कुंजी )) छोड़ दिया : + कुंजी = 0
@ पार्सर सेट करें । बफर 1 @ ( कुंजी ) = @ gl1 @ ( कुंजी )
}
सेट ब्रेसिज़ = पार्सर । फ़ॉर्म बफ़र ()
लिखना ।, कक्षा , "।" , विधि , ":" , ब्रेसिज़

mdef करें । क्रियान्वयन। स्पष्ट ()
सेट कुंजी = 0
के लिए
{
सेट कुंजी = $ ऑर्डर (@ parser । बफर 2 @ ( कुंजी )) छोड़ दिया : + कुंजी = 0
mdef करें । क्रियान्वयन। WriteLine (@ parser । बफर 2 @ ( कुंजी ))
}
mdef करें । % बचाओ ()
}
/// स्ट्रिंग को फॉर्मेट करें, जो फिर लौटती है
/// w ## वर्ग (Util.CodeFormat) .FormatString ("यदि x = 1 {s x = 1}")
ClassMethod FormatString ( % स्ट्रिंग के रूप में ) % स्ट्रिंग के रूप में
{

सेट पार्सर = .. % नया ()
पार्सर सेट करें । बफर 1 = "^ || बफर 1"
पार्सर सेट करें । बफर 2 = "^ || बफर 2 "
मार डालो @ पार्सर । Buffer1
मार डालो @ पार्सर । Buffer2

सेट रेंडेंड = $ चार (13,10)
पंक्तियाँ सेट करें = $ listfromstring ( str , rowend )
सेट कुंजी = 0
i = 1: 1: $ listlength ( पंक्तियाँ ) // डेटा को बफर से वैश्विक विधि से लिखें
{
@ पार्सर सेट करें । बफ़र 1 @ ( i ) = $ श्रोता ( पंक्तियाँ , i )
}
पार्सर करें । फ़ॉर्म बफ़र ()

सेट स्ट्रैट = ""
सेट कुंजी = ""
के लिए
{
सेट कुंजी = $ ऑर्डर (@ पार्सर । बफर 2 @ ( कुंजी )) पद छोड़ना : कुंजी = ""
सेट str = str _ $ सूची (@ पार्सर । बफर 2 @ ( कुंजी ))
}
सेट : $ सूची ( पंक्तियाँ , $ सूची ( पंक्तियाँ )) = "" str = str _ $ सूची ( " )
$ सूचीपत्र छोड़ें ( str , rowend )
}
/// इनपुट बफर से पाठ पढ़ें 
/// पाठ की सूची और उसके प्रकार की वापसी करता है 
/// पाठ प्रकार 
/// p - सफेद स्थान 
/// एस - स्ट्रिंग 
/// ई - लाइन का अंत 
/// ई - सामान्य रूप से पाठ का अंत 
/// {- { 
///} -} 
/// (- ( 
///) -) 
///; - एकल लाइन टिप्पणी की शुरुआत 
/// / * - एक बहु-पंक्ति टिप्पणी की शुरुआत 
/// * / - बहु-पंक्ति टिप्पणी का अंत
विधि ReadTerm () % सूची के रूप में
{
सेट : $ डेटा (@ .. बफ़र १ @ (.. करंटलाइन १ )) = ० .. करंटलाइन १ = .. करंटलाइन १ +, .. करंटपोस १ = १
पद छोड़ना : $ डेटा (@ .. बफर 1 @ (.. करंटलाइन 1 )) = 0 $ सूची ( "" , "ई" )
सेट str = @ .. बफ़र 1 @ (.. करंटलाइन 1 )
सेट करें char1 = $ अर्क ( str , .. CurrentPos1 , .. CurrentPos1 )
char2 = $ एक्स्ट्रेक्ट ( str , .. करंटपोस 1 +1, .. करंटपोस 1 +1)
सेट : char1 = "" .. करंटलाइन 1 = .. करंटलाइन 1 +1, करंटपोस 1 = 1
पद छोड़ना : char1 = "" $ सूची बनाना ( "" , "e" )
set .. करंटपोस 1 = .. करंटपोस 1 +1
पद छोड़ना : char1 = "" $ सूची बनाना ( char1 , "p" )
छोड़ दिया : char1 = $ char (9) $ सूची ( char1 , "p" )
पद छोड़ना : char1 = "{" $ सूची बनाना ( char1 , "{" )
पद छोड़ना : char1 = "}" $ सूची बनाना ( char1 , "}" )
पद छोड़ना : char1 = "(" $ सूची बनाना ( char1 , " ) (" )
पद छोड़ना : char1 = ")" $ सूची बनाना ( char1 , ")" )
छोड़ दिया : char1 = ";" $ सूची ( char1 , ";" )
if ( char1 = "/" ) && ( char2 = "/" ) सेट .. CurrentPos1 = .. CurrentPos1 +1 ने $ listbuild ( char1 _ char2 ; ";";
if ( char1 = "/" ) और& ( char2 = "*" ) सेट .. CurrentPos1 = .. CurrentPos1 +1 ने $ listbuild ( char1 _ char2 , "/ *" ) छोड़ दिया
if ( char1 = "*" ) && ( char2 = "/" ) सेट .. CurrentPos1 = .. CurrentPos1 +1 ने $ listbuild ( char1 _ char2 , "* /" ) छोड़ दिया
अगर ( char1 = "" "" )
{
सेट pos2 = $ ढूंढें ( str , "" "" , .. CurrentPos1 )
सेट पाठ = $ अर्क ( str , .. CurrentPos1 -1 , pos2 -1)
सेट .. करंटपोस १ = पॉस २
$ सूची बनाना ( पाठ , "s" )
}
$ सूची निर्माण ( char1 , "s" ) छोड़ें
}
/// एक ही ReadTerm, लेकिन तर्कों को अलग तरीके से परोसा और प्राप्त किया जाता है
विधि ReadTerm1 ( % स्ट्रिंग के रूप में ByRef प्रकार ) % स्ट्रिंग के रूप में
{
सेट Res = .. ReadTerm ()
सेट प्रकार = $ सूची ( रेस , 2)
$ श्रग छोड़ें ( रेस , 1)
}
/// टेक्स्ट को आउटपुट बफर में प्रिंट करें
विधि लिखें ( पाठ स्ट्रिंग% = "" )
{
सेट @ .. बफ़र 2 @ (.. करंटलाइन 2) = $ मिलता है (@ .. बफ़र 2 @ (.. करंट लिली 2 ) _ टेक्स्ट
}
/// आउटपुट बफर में लाइन का अनुवाद करें
विधि WriteCR ()
{
सेट .. करंटलाइन 2 = .. करंटलाइन 2 +1
}
/// टेक्स्ट स्ट्रिंग को इंडेंट करें
विधि मेकइंडेंट () % स्ट्रिंग के रूप में
{
इंडेंट सेट करें = $ char (9)
i = 1: 1 के लिए: LevelFigureBrace सेट इंडेंट = इंडेंट _ $ char (9)
i = 1: 1: .. LevelRoundBrace सेट इंडेंट = इंडेंट _ ""
इंडेंट छोड़ दिया
}
/// प्रारूप पाठ आंतरिक "बफर" में
विधि FormatBuffer ()
{
सेट स्तर = 0
के लिए
{
सेट पाठ = .. ReadTerm1 (; प्रकार ) छोड़ दिया : प्रकार = "ई"
do : type = "e" .. ProcessCR ( टेक्स्ट )
do : type = "p" .. प्रोसेसस्पेस ( पाठ )
do : टाइप = "" .. ProcessOnelineCommentOpen ( पाठ )
do : type = "/ *" .. ProcessMultilineCommentOpen ( पाठ )
do : type = "* /" .. ProcessMultilineCommentClose ( पाठ )
do : type = "(" .. ProcessRoundBraceOpen ( पाठ )
do : type = ")" .. ProcessRoundBraceClose ( पाठ )
do : type = "{" .. ProcessFigureBraceOpen ( पाठ )
do : type = "}" .. ProcessFigureBraceClose ( पाठ )
do : type = "s" .. ProcessCommonCode ( पाठ )
सेट : .. LevelFigureBrace > स्तर स्तर = .. LevelFigureBrace
}
स्तर छोड़ दिया
}
}

शैली में वर्ग-हैंडलर वर्ग "पंक्ति के अंत में ब्रैकेट"। यदि यह शैली बेहतर है, तो आपको UtilCodeFormat3 के साथ UserAction विधि से UtilCodeFormat वर्ग में कॉल को बदलने की आवश्यकता है।

Util.CodeFormat3 क्लास

क्लास Util.CodeFormat3 Util.CodeFormat का विस्तार करता है
{
/// अंतिम पंक्ति फ़ीड वापस रोल करें
विधि रिटर्नसीआर ()
{
set .. करंटलाइन 2 = .. करंटलाइन -2
}
/// अंतिम स्थान वापस रोल करें
विधि रिटर्नस्पेस ()
{
सेट str = @ .. बफ़र 2 @ (.. करंटलाइन 2 )
सेट लेन = $ लंबाई ( str )
के लिए
{
अंतिम सेट = $ अर्क ( str , len , len )
छोड़ दिया :( lastchar '= " ) && ( lastchar ' = $ char (9))
सेट str = $ अर्क ( str , 1, लेन -1)
set len = लेन -1
सेट @ .. बफर 2 @ (.. करंटलाइन 2) = str
}
}
/// प्रक्रिया खोलने ब्रेसिज़
विधि ProcessFigureBraceOpen ( % स्ट्रिंग के रूप में पाठ )
{
छोड़ दिया :( .. LevelRoundBrace ) .. ProcessCommonCode ( पाठ )
छोड़ दिया :( .. InMultiLineComment ) .. ProcessCononCode ( पाठ )
छोड़ दिया :( .. InSleleLineComment ) .. ProcessCononCode ( पाठ )
करते हैं : '.. LineHasCode .. ReturnCR ()
करो .. रिटर्नस्पेस ()
करो .. लिखो ( "" )
करो .. लिखो ( पाठ )
set .. LevelFigureBrace = .. LevelFigureBrace +1

do .. WriteCR ()
set .. LineHasCode = 0, .. SkipSpace = 1, .. जरूरत = 1, .. SkipCR = 1
1 छोड़ दिया
}
}

क्लास एक्सटेंशन स्टूडियो कैच पूरी तरह से:

Util.StudioExtension वर्ग

कक्षा Util.StudioExtension% Studio.Extension.Base का विस्तार करता है
{
XData मेनू
{
< मेनूबेस >
< मेनू का नाम = "प्रारूप" प्रकार = "1" >
< MenuItem नाम = "PlusTab" />
< MenuItem नाम = "MinusTab" />
< MenuItem सेपरेटर = "1" />
< MenuItem नाम = "सुधारना" />
< MenuItem नाम = "सुधारक कार्य" = "100" /> सहेजें
< MenuItem सेपरेटर = "1" />
< MenuItem नाम = "CommentBlock" />
< MenuItem नाम = "UnCommentBlock" />
</ मेनू >
</ MenuBase >
}
OnMenuItem विधि ( मेनू नाम % स्ट्रिंग के रूप में , आंतरिक नाम % स्ट्रिंग के रूप में , चयनित टेक्स्ट स्ट्रिंग स्ट्रिंग के रूप में
ByRef % Boolean के रूप में सक्षम , ByRef DisplayName % स्ट्रिंग के रूप में ) % स्थिति के रूप में
{
सेट : MenuName = "फ़ॉर्मेट" DisplayName = "फ़ॉर्मेट"
set : MenuName = "Format,PlusTab" DisplayName = "->| "
set : MenuName = "Format,MinusTab" DisplayName = "|<- "
set : MenuName = "Format,ReformatDocument" DisplayName = " "
set : MenuName = "Format,ReformatSelection" DisplayName = " "
set : MenuName = "Format,CommentBlock" DisplayName = " "
set : MenuName = "Format,UnCommentBlock" DisplayName = " "
set Enabled =1
set ext = $piece ( InternalName , "." , $length ( InternalName , "." ))
set :( MenuName = "Format,ReformatDocument" )&&( ext '= "MAC" )&&( ext '= "CLS" ) Enabled =0
set :( MenuName = "Format,ReformatSelection" )&&( SelectedText = "" ) Enabled =0
set :( MenuName = "Format,MinusTab" )&&( SelectedText = "" ) Enabled =0
set :( MenuName = "Format,UnCommentBlock" )&&( ##class ( Util.FormatComment ). CheckForComment ( SelectedText )=0) Enabled =0
quit 1
}
/* -
Type = 0 - ,
InternalName - ,
InternalName - ,
SelectedText - ( )
Type = 1 - ,
Name = 0 -
Name = 1 -
Name = 2 -
Name = 3 -
Name = 4 -
Name = 5 -
InternalName - ,
Action
0 -
1 - //. Target.
2 - csp . Target
3 - EXE - . Target
4 - , Target
5 - , Target. . 'test.mac:label+10', test.mac 'label+10'.
6 - , Target
7 - Yes/No/Cancel. Target. Msg.
Reload , .
* /
Method UserAction( Type As %Integer , Name As %String , InternalName As %String , SelectedText As %String ,
ByRef Action As %String , ByRef Target As %String , ByRef Msg As %String , ByRef Reload As %Boolean ) As %Status
{
set ext = $zconvert ( $piece ( InternalName , "." , $length ( InternalName , "." )), "U" )
set docname = $extract ( InternalName ,1,*-4)
if Name = "Format,PlusTab"
{
set Action =4 ;
set Target = ##class ( Util.FormatTab ). PlusTab ( SelectedText , ext = "CSP" )
}
if Name = "Format,MinusTab"
{
set Action =4 ;
set Target = ##class ( Util.FormatTab ). MinusTab ( SelectedText , ext = "CSP" )
}
if Name = "Format,CommentBlock"
{
set Action =4
set Target = ##class ( Util.FormatComment ). AddComment ( SelectedText )
}
if Name = "Format,UnCommentBlock"
{
set Action =4
set Target = ##class ( Util.FormatComment ). RemoveComment ( SelectedText )
}
if Name = "Format,ReformatSelection"
{
set Action =4
set Target = ##class ( Util.CodeFormat ). FormatString ( SelectedText )
}
if Name = "Format,ReformatDocument"
{
set Action =0
do : ext = "MAC" ##class ( Util.CodeFormat ). FormatMAC ( docname )
do : ext = "CLS" ##class ( Util.CodeFormat ). FormatClass ( docname )
}
quit 1
}
}

हो गया!

स्टूडियो कैच की कार्यक्षमता को बढ़ाने का एक और तरीका

एक संस्करण नियंत्रण वर्ग बनाना

इंडेंट क्लास सी

टिप्पणी करने / कोड करने के लिए कक्षा

पाठ स्वरूपण

More articles: