1: 
            using System;

             2: 
            using System.Collections;

             3: 
            using EnvDTE;

             4: 
            using EnvDTE80;

             5: 
            using Extensibility;

             6: 
            using Microsoft.VisualStudio.CommandBars;

             7:  

             8: 
            namespace SmartPaster2010

             9: {

             10: 
            ///<summary>The object
for implementing an Add-in.</summary>
          

             11: 
            ///<seealso
class='IDTExtensibility2' />
          

             12: 
            public
            class Connect
: IDTExtensibility2

             13:  {

             14: 
            private
            readonly ArrayList
_pasteAsButtons;

             15: 
            private
            readonly SmartPaster
_smartPaster;

             16: 
            private CommandBarPopup
_pasteAsPopup;

             17:  

             18: 
            ///<summary>Implements
the constructor for the Add-in object. Place your initialization code within this
method.</summary>
          

             19: 
            public Connect()

             20:  {

             21:  _pasteAsButtons = new ArrayList();

             22:  _smartPaster = new SmartPaster();

             23:  }

             24:  

             25: 
            ///<summary>Implements
the OnConnection method of the IDTExtensibility2 interface. Receives notification
that the Add-in is being loaded.</summary>
          

             26: 
            ///<param term='application'>Root
object of the host application.</param>
          

             27: 
            ///<param term='connectMode'>Describes
how the Add-in is being loaded.</param>
          

             28: 
            ///<param term='addInInst'>Object
representing this Add-in.</param>
          

             29: 
            ///<seealso
class='IDTExtensibility2' />
          

             30: 
            public
            void OnConnection(object application,
ext_ConnectMode connectMode, 

            object addInInst, ref Array
custom)

             31:  {

             32:  _applicationObject = (DTE2)application;

             33:  _addInInstance = (AddIn)addInInst;

             34:  

             35:  

             36: 
            //check for the commands
          

             37: 
            bool cmdExists
= false;

             38: 
            foreach (Command cmd in _applicationObject.Commands)

             39:  {

             40: 
            if (cmd.Name.EndsWith("PasteAsComment",
StringComparison.OrdinalIgnoreCase))

             41:  {

             42:  cmdExists = true;

             43: 
            break;

             44:  }

             45:  }

             46:  

             47: 
            try
          

             48:  {

             49: 
            if (!cmdExists)

             50:  {

             51:  AddPasteAsCommands();

             52:  }

             53:  

             54: 
            if (connectMode ==
ext_ConnectMode.ext_cm_Startup && _pasteAsPopup == null)

             55:  {

             56: 
            //Add items to the Context
(Right-Click) Menu
          

             57: 
            //find the position
of the &Paste command
          

             58: 
            int position = 0;

             59:  

             60:  CommandBar codeWindow = _applicationObject.CommandBars["Code
Window"];

             61:  

             62: 
            for (int i
= 1; i <= codeWindow.Controls.Count; i++)

             63:  {

             64: 
            if (codeWindow.Controls[i].Caption
== "&Paste")

             65:  {

             66:  position = i;

             67: 
            break;

             68:  }

             69:  }

             70:  

             71: 
            //add the popup
menu "Paste As...", which may already be on the menu
          

             72:  _pasteAsPopup = (CommandBarPopup)codeWindow.Controls.Add(

(int)MsoControlType.msoControlPopup, 1, Type.Missing,
position + 1, Type.Missing);

             73:  _pasteAsPopup.Caption = "Paste
As ...";

             74:  AddPasteAsButtons();

             75:  }

             76:  

             77:  }

             78: 
            catch (Exception ex)

             79:  {

             80:  System.Diagnostics.Debug.WriteLine(ex.Message);

             81:  }

             82:  }

             83:  

             84: 
            private
            void AddPasteAsCommands()

             85:  {

             86: 
            //no configure or regionize
because I never use 'em
          

             87:  _applicationObject.Commands.AddNamedCommand(_addInInstance, "PasteAsComment", "Paste
As Comment", "Pastes clipboard text as a comment.", true,
22, null, Convert.ToInt32(vsCommandStatus.vsCommandStatusSupported)
+ Convert.ToInt32(vsCommandStatus.vsCommandStatusEnabled));

             88:  

             89:  _applicationObject.Commands.AddNamedCommand(_addInInstance, "PasteAsString", "Paste
As String", "Pastes clipboard text as a string literal.", true,
22, null, Convert.ToInt32(vsCommandStatus.vsCommandStatusSupported)
+ Convert.ToInt32(vsCommandStatus.vsCommandStatusEnabled));

             90:  

             91:  _applicationObject.Commands.AddNamedCommand(_addInInstance, "PasteAsStringBuilder", "Paste
As StringBuilder", "Pastes clipboard text as a stringbuilder.", true,
22, null, Convert.ToInt32(vsCommandStatus.vsCommandStatusSupported)
+ Convert.ToInt32(vsCommandStatus.vsCommandStatusEnabled));

             92:  }

             93:  

             94:  

             95: 
            private
            void AddPasteAsButtons()

             96:  {

             97:  

             98: 
            //now the buttons
          

             99:  CommandBarButton pasteAsButton;

             100:  

             101: 
            //add "Comment"
          

             102:  pasteAsButton = AddCommandButton();

             103:  pasteAsButton.Caption = "Comment";

             104:  pasteAsButton.TooltipText = "Inserts
clipboard with each line prefixed with a comment character";

             105:  pasteAsButton.Click += PasteAsComment;

             106:  _pasteAsButtons.Add(pasteAsButton);

             107:  

             108: 
            //add "String"
          

             109:  pasteAsButton = AddCommandButton();

             110:  pasteAsButton.Caption = "String";

             111:  pasteAsButton.TooltipText = "Inserts
enquoted clipboard text with line breaks and other characters escaped";

             112:  pasteAsButton.Click += PasteAsString;

             113:  _pasteAsButtons.Add(pasteAsButton);

             114:  

             115: 
            //add "StringBuilder"
          

             116:  pasteAsButton = AddCommandButton();

             117:  pasteAsButton.Caption = "StringBuilder";

             118:  pasteAsButton.TooltipText = "Inserts
enquoted clipboard text built up by a stringbuilder.";

             119:  pasteAsButton.Click += PasteAsStringBuilder;

             120:  _pasteAsButtons.Add(pasteAsButton);

             121:  

             122:  }

             123:  

             124: 
            private CommandBarButton
AddCommandButton()

             125:  {

             126:  var pasteAsButton = (CommandBarButton)_pasteAsPopup.Controls.Add((int)MsoControlType.msoControlButton);

             127: 
            //in 2010, CommandBarButton.FaceId
throws a DeprecatedException.
          

             128: 
            //pasteAsButton.FaceId = 22;
          

             129:  pasteAsButton.Visible = true;

             130: 
            return pasteAsButton;

             131:  }

             132:  

             133: 
            #region
            "PasteAs
Handlers"
          

             134:  

             135: 
            ///<summary>
          

             136: 
            ///Occurs when the user clicks
the PasteAsString button.
          

             137: 
            ///</summary>
          

             138: 
            ///<param name="ctrl">
          

             139: 
            ///Denotes the
CommandBarButton control that initiated the event. 
          

             140: 
            ///</param>
          

             141: 
            ///<param name="cancelDefault">
          

             142: 
            ///False if the default behavior
associated with the CommandBarButton control occurs, unless its canceled by another
process or add-in. 
          

             143: 
            ///</param>
          

             144: 
            private
            void PasteAsString(CommandBarButton
ctrl, refbool cancelDefault)

             145:  {

             146:  _smartPaster.PasteAsString(_applicationObject);

             147:  }

             148:  

             149:  

             150: 
            ///<summary>
          

             151: 
            ///Occurs when
the user clicks the PasteAsComment button.
          

             152: 
            ///</summary>
          

             153: 
            ///<param name="ctrl">
          

             154: 
            ///Denotes the CommandBarButton
control that initiated the event. 
          

             155: 
            ///</param>
          

             156: 
            ///<param name="cancelDefault">
          

             157: 
            ///False if the
default behavior associated with the CommandBarButton control occurs, unless its canceled
by another process or add-in. 
          

             158: 
            ///</param>
          

             159: 
            private
            void PasteAsComment(CommandBarButton
ctrl, refbool cancelDefault)

             160:  {

             161:  _smartPaster.PasteAsComment(_applicationObject);

             162:  }

             163:  

             164: 
            ///<summary>
          

             165: 
            ///Occurs when
the user clicks the PasteAsStringBuilder button.
          

             166: 
            ///</summary>
          

             167: 
            ///<param name="ctrl">
          

             168: 
            ///Denotes the CommandBarButton
control that initiated the event. 
          

             169: 
            ///</param>
          

             170: 
            ///<param name="cancelDefault">
          

             171: 
            ///False if the
default behavior associated with the CommandBarButton control occurs, unless its canceled
by another process or add-in. 
          

             172: 
            ///</param>
          

             173: 
            private
            void PasteAsStringBuilder(CommandBarButton
ctrl, refbool cancelDefault)

             174:  {

             175:  _smartPaster.PasteAsStringBuilder(_applicationObject);

             176:  }

             177: 
            #endregion
          

             178:  

             179: 
            #region
            "Exec"
          

             180:  

             181: 
            ///<summary>
          

             182: 
            /// Implements the Exec method
of the IDTCommandTarget interface.
          

             183: 
            /// This is called
when the command is invoked.
          

             184: 
            ///</summary>
          

             185: 
            ///<param name='commandName'>
          

             186: 
            /// The name of the command
to execute.
          

             187: 
            ///</param>
          

             188: 
            ///<param name='executeOption'>
          

             189: 
            /// Describes
how the command should be run.
          

             190: 
            ///</param>
          

             191: 
            ///<param name='varIn'>
          

             192: 
            /// Parameters passed from
the caller to the command handler.
          

             193: 
            ///</param>
          

             194: 
            ///<param name='varOut'>
          

             195: 
            /// Parameters
passed from the command handler to the caller.
          

             196: 
            ///</param>
          

             197: 
            ///<param name='handled'>
          

             198: 
            /// Informs the caller if
the command was handled or not.
          

             199: 
            ///</param>
          

             200: 
            ///<seealso class='Exec'
/>
          

             201: 
            public
            void Exec(string commandName,
vsCommandExecOption executeOption, refobject varIn, refobject varOut, refbool handled)

             202:  {

             203:  handled = false;

             204: 
            if ((executeOption
== vsCommandExecOption.vsCommandExecOptionDoDefault))

             205:  {

             206:  handled = true;

             207: 
            switch (commandName)

             208:  {

             209: 
            //case "SmartPaster.Connect.Configure":
          

             210: 
            // //show the config form
          

             211: 
            // SmartPasterForm
myForm = new SmartPasterForm();
          

             212: 
            // myForm.ShowDialog();
          

             213: 
            // //since config
may have changed, show/hide buttons
          

             214: 
            // EnableContextMenuButtons();
          

             215:  

             216: 
            // break;
          

             217: 
            case
            "SmartPaster.Connect.PasteAsComment":

             218:  _smartPaster.PasteAsComment(_applicationObject);

             219: 
            break;

             220: 
            case
            "SmartPaster.Connect.PasteAsString":

             221:  _smartPaster.PasteAsString(_applicationObject);

             222: 
            break;

             223: 
            case
            "SmartPaster.Connect.PasteAsStringBuilder":

             224:  _smartPaster.PasteAsStringBuilder(_applicationObject);

             225: 
            break;

             226: 
            //case "SmartPaster.Connect.PasteAsRegion":
          

             227: 
            // _smartPaster.PasteAsRegion(_applicationObject);
          

             228: 
            // break;
          

             229: 
            default:

             230:  handled = false;

             231: 
            break;

             232:  }

             233:  }

             234:  }

             235: 
            #endregion
          

             236:  

             237: 
            #region Standard
Template Stuff

             238: 
            ///<summary>
          

             239: 
            ///Implements
the OnDisconnection method of the IDTExtensibility2 interface. Receives notification
that the Add-in is being unloaded.
          

             240: 
            ///</summary>
          

             241: 
            ///<param name="disconnectMode">The
disconnect mode.</param>
          

             242: 
            ///<param name="custom">The
custom.</param>
          

             243: 
            ///<seealso
class="IDTExtensibility2"/>
          

             244: 
            public
            void OnDisconnection(ext_DisconnectMode
disconnectMode, ref Array custom)

             245:  {

             246: 
            if (_pasteAsPopup
!= null && 

             247:  (disconnectMode == ext_DisconnectMode.ext_dm_UserClosed
|| disconnectMode == ext_DisconnectMode.ext_dm_HostShutdown))

             248:  {

             249:  _pasteAsPopup.Delete(true);

             250:  }

             251:  }

             252:  

             253: 
            ///<summary>Implements
the OnAddInsUpdate method of the IDTExtensibility2 interface. Receives notification
when the collection of Add-ins has changed.</summary>
          

             254: 
            ///<param term='custom'>Array
of parameters that are host application specific.</param>
          

             255: 
            ///<seealso
class='IDTExtensibility2' /> 
          

             256: 
            public
            void OnAddInsUpdate(ref Array
custom)

             257:  {

             258:  }

             259:  

             260: 
            ///<summary>Implements
the OnStartupComplete method of the IDTExtensibility2 interface. Receives notification
that the host application has completed loading.</summary>
          

             261: 
            ///<param term='custom'>Array
of parameters that are host application specific.</param>
          

             262: 
            ///<seealso class='IDTExtensibility2'
/>
          

             263: 
            public
            void OnStartupComplete(ref Array
custom)

             264:  {

             265:  }

             266:  

             267: 
            ///<summary>Implements
the OnBeginShutdown method of the IDTExtensibility2 interface. Receives notification
that the host application is being unloaded.</summary>
          

             268: 
            ///<param term='custom'>Array
of parameters that are host application specific.</param>
          

             269: 
            ///<seealso
class='IDTExtensibility2' />
          

             270: 
            public
            void OnBeginShutdown(ref Array
custom)

             271:  {

             272:  }

             273:  

             274: 
            private DTE2 _applicationObject;

             275: 
            private AddIn
_addInInstance;

             276: 
            #endregion
          

             277:  

             278: 
            ///<summary>
          

             279: 
            ///Queries the
status.
          

             280: 
            ///</summary>
          

             281: 
            ///<param name="commandName">Name
of the command.</param>
          

             282: 
            ///<param name="neededText">The
needed text.</param>
          

             283: 
            ///<param name="statusOption">The
status option.</param>
          

             284: 
            ///<param name="commandText">The
command text.</param>
          

             285: 
            public
            void QueryStatus(string commandName,
vsCommandStatusTextWanted neededText, ref vsCommandStatus
statusOption, refobject commandText)

             286:  {

             287: 
            if (neededText
== vsCommandStatusTextWanted.vsCommandStatusTextWantedNone)

             288:  {

             289: 
            if (commandName.StartsWith("SmartPaster.Connect"))

             290:  {

             291: 
            if (((_applicationObject.ActiveDocument
!= null)) && ((_applicationObject.ActiveDocument.Object("TextDocument")
!= null)))

             292:  {

             293:  statusOption = vsCommandStatus.vsCommandStatusEnabled
| vsCommandStatus.vsCommandStatusSupported;

             294:  }

             295: 
            else
          

             296:  {

             297:  statusOption = vsCommandStatus.vsCommandStatusSupported;

             298:  }

             299:  }

             300: 
            else
          

             301:  {

             302:  statusOption = vsCommandStatus.vsCommandStatusUnsupported;

             303:  }

             304:  }

             305:  }

             306:  }

             307: }

             1: 
            using System;

             2: 
            using System.IO;

             3: 
            using System.Text;

             4: 
            using System.Windows.Forms; //clipboard

             5: 
            using EnvDTE;

             6: 
            using EnvDTE80;

             7:  

             8: 
            namespace SmartPaster2010

             9: {

             10: 
            /// <summary>
          

             11: 
            /// Class responsible
for doing the pasting/manipulating of clipdata.
          

             12: 
            /// </summary>
          

             13: 
            internal
            sealed
            class SmartPaster

             14:  {

             15: 
            /// <summary>
          

             16: 
            /// Convient property to retrieve
the clipboard text from the clipboard
          

             17: 
            /// </summary>
          

             18: 
            private
            static
            string ClipboardText

             19:  {

             20:  get

             21:  {

             22:  IDataObject iData = Clipboard.GetDataObject();

             23: 
            if (iData.GetDataPresent(DataFormats.Text))

             24: 
            return Convert.ToString(iData.GetData(DataFormats.Text));

             25: 
            return
            string.Empty;

             26:  }

             27:  }

             28:  

             29: 
            #region
            "Stringinize"
          

             30: 
            /// <summary>
          

             31: 
            /// Stringinizes
text passed to it for use in C#
          

             32: 
            /// </summary>
          

             33: 
            /// <param name="txt">Text
to be Stringinized</param>
          

             34: 
            /// <returns>C# Stringinized
text</returns>
          

             35: 
            private
            static
            string StringinizeInCs(string txt)

             36:  {

             37: 
            //c# quote character
-- really just a "
          

             38: 
            const
            string qChr
= "\"";

             39:  

             40: 
            //sb to work with
          

             41:  var sb = new StringBuilder(txt);

             42:  

             43: 
            //escape appropriately
          

             44: 
            //escape the quotes with ""
          

             45:  sb.Replace(qChr, qChr + qChr);

             46:  

             47: 
            //insert " at beginning
and end
          

             48:  sb.Insert(0, "@" + qChr);

             49:  sb.Append(qChr);

             50: 
            return sb.ToString();

             51:  }

             52: 
            #endregion
          

             53:  

             54: 
            #region
            "Commentize"
          

             55: 
            /// <summary>
          

             56: 
            /// Commentizes text passed
to it for use in C#
          

             57: 
            /// </summary>
          

             58: 
            /// <param name="txt">Text
to be Stringinized</param>
          

             59: 
            /// <returns>C#
Commentized text</returns>
          

             60: 
            private
            static
            string CommentizeInCs(string txt)

             61:  {

             62: 
            const
            string cmtChar
= "//";

             63:  

             64:  var sb = new StringBuilder(txt.Length);

             65:  

             66: 
            //process the passed string
(txt), one line at a time
          

             67: 
            //the original
was horrible WTF code
          

             68: 
            using (var reader = new StringReader(txt))

             69:  {

             70: 
            string line;

             71: 
            while ((line
= reader.ReadLine()) != null)

             72:  {

             73:  sb.AppendLine(cmtChar + line);

             74:  }

             75:  }

             76:  

             77: 
            return sb.ToString();

             78:  }

             79: 
            #endregion
          

             80:  

             81: 
            #region
            "Stringbuilderize"
          

             82: 
            private
            static
            string StringbuilderizeInCs(string txt, string sbName)

             83:  {

             84: 
            //c# quote character -- really
just a "
          

             85: 
            const
            string qChr
= "\"";

             86:  

             87: 
            //sb to work with
          

             88:  var sb = new StringBuilder(txt);

             89:  

             90: 
            //escape \,", and {}
          

             91:  sb.Replace(qChr, qChr + qChr);

             92:  

             93: 
            //process the passed
string (txt), one line at a time
          

             94:  

             95: 
            //dump the stringbuilder
into a temp string
          

             96: 
            string fullString =
sb.ToString();

             97:  sb.Clear(); //lovely
.net 4 - sb.Remove(0, sb.Length);

             98:  

             99: 
            //the original
was horrible WTF code
          

             100: 
            using (var reader
= new StringReader(fullString))

             101:  {

             102: 
            string line;

             103: 
            while ((line
= reader.ReadLine()) != null)

             104:  {

             105:  sb.Append(sbName + ".AppendLine(");

             106:  sb.Append("@" + qChr);

             107:  sb.Append(line.Replace("\t", "\\t"));

             108:  sb.AppendLine(qChr + ");");

             109:  }

             110:  }

             111:  

             112: 
            //TODO: Better '@"" + ' replacement
to not cover inside strings
          

             113:  sb.Replace("@" +
qChr + qChr + " + ", "");

             114:  

             115: 
            //add the dec
statement
          

             116:  sb.Insert(0, "StringBuilder
" + sbName + " = new StringBuilder(" + txt.Length
+ ");" + Environment.NewLine);

             117:  

             118: 
            //and return
          

             119: 
            return sb.ToString();

             120:  }

             121: 
            #endregion
          

             122:  

             123: 
            /// <summary>
          

             124: 
            /// Inserts text at current
cursor location in the application
          

             125: 
            /// </summary>
          

             126: 
            /// <param name="application">application
with activewindow</param>
          

             127: 
            /// <param
name="text">text to insert</param>
          

             128: 
            private
            static
            void Paste(DTE2
application, string text)

             129:  {

             130: 
            //get the text document
          

             131:  var txt = (TextDocument)application.ActiveDocument.Object("TextDocument");

             132:  

             133: 
            //get an edit
point
          

             134:  EditPoint ep = txt.Selection.ActivePoint.CreateEditPoint();

             135:  

             136: 
            //get a start point
          

             137:  EditPoint sp = txt.Selection.ActivePoint.CreateEditPoint();

             138:  

             139: 
            //open the undo
context
          

             140: 
            bool isOpen = application.UndoContext.IsOpen;

             141: 
            if (!isOpen)

             142:  application.UndoContext.Open("SmartPaster");

             143:  

             144: 
            //clear the selection
          

             145: 
            if (!txt.Selection.IsEmpty)

             146:  txt.Selection.Delete();

             147:  

             148: 
            //insert the text
          

             149: 
            //ep.Insert(Indent(text,
ep.LineCharOffset))
          

             150:  ep.Insert(text);

             151:  

             152: 
            //smart format
          

             153:  sp.SmartFormat(ep);

             154:  

             155: 
            //close the context
          

             156: 
            if (!isOpen)

             157:  application.UndoContext.Close();

             158:  }

             159:  

             160: 
            #region
            "Paste
As ..."
          

             161:  

             162: 
            /// <summary>
          

             163: 
            /// Public method
to paste and format clipboard text as string the cursor 
          

             164: 
            /// location for the configured
or active window's langage .
          

             165: 
            /// </summary>
          

             166: 
            /// <param name="application">application
to insert</param>
          

             167: 
            public
            void PasteAsString(DTE2
application)

             168:  {

             169:  Paste(application, StringinizeInCs(ClipboardText));

             170:  }

             171:  

             172: 
            /// <summary>
          

             173: 
            /// Public method
to paste and format clipboard text as comment the cursor 
          

             174: 
            /// location for the configured
or active window's langage .
          

             175: 
            /// </summary>
          

             176: 
            /// <param name="application">application
to insert</param>
          

             177: 
            public
            void PasteAsComment(DTE2
application)

             178:  {

             179:  Paste(application, CommentizeInCs(ClipboardText));

             180:  }

             181:  

             182:  

             183: 
            /// <summary>
          

             184: 
            /// Public method to paste
format clipboard text into a specified region
          

             185: 
            /// </summary>
          

             186: 
            /// <param name="application">application
to insert</param>
          

             187: 
            public
            void PasteAsRegion(DTE2
application)

             188:  {

             189: 
            //get the region
name
          

             190: 
            const
            string region
= "myRegion";

             191:  

             192: 
            //it's so simple, we really
don't need a function
          

             193: 
            string csRegionized
= "#region " + region + Environment.NewLine + ClipboardText
+ Environment.NewLine + "#endregion";

             194:  

             195: 
            //and paste
          

             196:  Paste(application, csRegionized);

             197:  }

             198:  

             199: 
            /// <summary>
          

             200: 
            /// Public method to paste
and format clipboard text as stringbuilder the cursor 
          

             201: 
            /// location for
the configured or active window's langage .
          

             202: 
            /// </summary>
          

             203: 
            /// <param
name="application">application to insert</param>
          

             204: 
            public
            void PasteAsStringBuilder(DTE2
application)

             205:  {

             206: 
            const
            string stringbuilder
= "sb";

             207:  Paste(application, StringbuilderizeInCs(ClipboardText,
stringbuilder));

             208:  }

             209:  

             210: 
            #endregion
          

             211:  }

             212: }