Peter,

In reverse order;

The only custom EditControl example I have been exposed to is included in the Workflow SDK installation.  There is a 'Samples' folder in the same folder as the Activity Proxy Generator.exe.  The sample solution has a project called 'GetTagComments' that has a simple button custom EditControl.  Everything else has been through my own research.

When you run your custom workflow activity through the Activity Proxy Generator there are options to make tokens available to other workflow activities.  Not sure if you need to pass simple text tokens or more complex serialized objects but you can make those tokens available to other activities.

When I need to encrypt/decrypt connection information I use the System.Security.Cryptography namespace.  In the example you mention I would do a decryption of the stored credentials in the UpdatePropertyPane Sub to update the controls and then I would do an encryption of the plain text in the controls in the Save sub.  (So the actual workflow XML contains encrypted credentials)

In the example you mentioned I am not passing the serialized FtpDestination object to any other activity as everything FTP related is handled internally to the custom activity.  I am confident though that you could pass a serialized object as a token to another activity.  (I would check to see if there is perhaps a maximum token length that you might need to be aware of?)

Mike,

Not quite sure what you are looking for but here are some pointers (hopefully not too basic);

To start with in the activity class I usually declare the properties that will contain the values for the control as type Object.  I found that this will 'trick' the Proxy Generator into allowing you to select the new custom edit control instead of assuming you want to use an existing control type.  (You can always edit the proxy code after it has been generated to use your new custom control no matter what code the generator spits out)

Next, in the custom control class you need to inherit from the Laserfiche.UI.EditPanel.EditPanelControlBase class.  You also need to override some of the default methods.  Here is a code snip for a very basic custom user control with only a textbox;

Imports Laserfiche.UI.EditPanel

Public Class DemoUserControl
    Inherits EditPanelControlBase

    Private _textValue As String = String.Empty

#Region "Default Method Overrides"
    
    Public Overrides Sub NotifyPanelShown()
        Me.UpdatePanel()
    End Sub

    Public Overrides Sub Save()
        Me.Value = _textValue
    End Sub

#End Region

#Region "Control Events"

    Private Sub ValueTextBox_TextChanged(sender As Object, e As System.EventArgs) Handles ValueTextBox.TextChanged
        _textValue = Me.ValueTextBox.Text
        Me.Save()
    End Sub

#End Region

#Region "Helpers"

    Private Sub UpdatePanel()

        _textValue = Me.Value
        Me.ValueTextBox.Text = _textValue

    End Sub

#End Region

End Class

The important points are the class level variable for the value of the control and the overrides of the OnNotifyPanelShown and Save methods. 

Once the project is built you should now be able to select your new custom control as the control to use for editing the property in the Proxy Generator;

Typically our custom user controls contain many standard .NET controls not just a single textbox so the class level variable is more commonly an instance of a class that will contain all of the values for all of the controls in the custom control.  We do our own serialization of the value class to store it in the activity class property.  Something like this;

And in the UpdatePanel routine the value gets deserialized and the .NET controls are updated with the correct values;

Finally in the Save routine the class is serialized and stored in the controls Value property;

Let me know if you need additional information or have specific questions.