|
|
 | Controls | |
| Properties | |
| Additional | |
|
|
|
|
Manual
Function KG_VerifyRegistrationInfoFromProjectW
KG_VerifyRegistrationInfoFromProjectW is used for verifying the registration information and extracting registration key parameters from unicode-based registration information. The function has two parameters, one of them is a pointer to the TKeyVerifyParamsW structure, the other one is unicode - null terminated string - the path to the Enigma Protector project file. The function reads secure information from the project file, so it does not require secure parameters PublicKey, KeyMode, KeyBase and EncryptedConstant in the TKeyVerifyParamsW structure.
Return Values
| EP_NO_ERROR=0 |
the function succeeds, TKeyVerifyParamsW structure contains registration key parameters; |
| EP_ERROR_UNKNOWN=1 |
unknown error |
| EP_ERROR_KEYBUFFEREMPTY=2 |
memory buffer for registration key is not allocated |
| EP_ERROR_KEYBUFFERISLESS=3 |
size of allocated memory for registration key is less than required |
| EP_ERROR_REGINFOEMPTY=4 |
registration information is not specified |
| EP_ERROR_REGINFOTOOLARGE=5 |
registration information is empty (has a null size) |
| EP_ERROR_PRIVATEKEYISNOTSET=6 |
private key is not set |
| EP_ERROR_PUBLICKEYISNOTSET=7 |
public key is not set |
| EP_ERROR_PRIVATEKEYISINVALID=8 |
private key is invalid |
| EP_ERROR_PUBLICKEYISINVALID=9 |
public key is invalid |
| EP_ERROR_KEYMODEISINVALID=10 |
key mode is invalid |
| EP_ERROR_KEYBASEISINVALID=11 |
key base is invalid |
| EP_ERROR_CURRENTDATEISINVALID=12 |
current date is invalid |
| EP_ERROR_EXPIRATIONDATEISINVALID=13 |
expiration date is invalid |
| EP_ERROR_KEYISINVALID=14 |
key is invalid |
| EP_ERROR_HARDWAREID=15 |
hardware id is invalid |
| EP_ERROR_HARDWAREBUFFEREMPTY=16 |
hardware id buffer is empty |
| EP_ERROR_HARDWAREIDINVALIDFORKEY=17 |
hardware id is invalid for the key |
| EP_ERROR_PROJECTFILENOTFOUND=18 |
project file is not found |
| EP_ERROR_INVALIDPROJECTFILE=19 |
project file is invalid |
| EP_ERROR_EXECUTIONSNUMBERINVALID=20 |
executions number is invalid |
| EP_ERROR_DAYSNUMBERINVALID=21 |
days number is invalid |
| EP_ERROR_COUNTRYCODEINVALID=22 |
country code is invalid |
| EP_ERROR_RUNTIMEINVALID=23 |
run-time value is invalid |
| EP_ERROR_GLOBALTIMEINVALID=24 |
global time is invalid |
| EP_ERROR_INSTALLBEFOREINVALID=25 |
register before date is invalid |
| EP_ERROR_INSTALLAFTERINVALID=26 |
register after date is invalid |
Definition Show/Hide Delphi function definition
function KG_VerifyRegistrationInfoFromProjectW(ProjectFile : PWideChar; kv : PKeyVerifyParamsW) : dword; external 'keygen.dll' name 'KG_VerifyRegistrationInfoFromProjectW';
Show/Hide C++ function definition extern "C" __declspec( dllimport ) __stdcall int KG_VerifyRegistrationInfoFromProjectW(wchar_t* pfile, PKeyVerifyParamsW kv);
Show/Hide C# (.NET) function definition public class Enigma_KeyGen_IDE
{
[DllImport("keygen.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]
public static extern uint KG_VerifyRegistrationInfoFromProjectW(string FileName, ref TKeyVerifyParamsW kv);
}
ExamplesShow/Hide Delphi function example procedure TfrmMain.btnVerifyPClick(Sender: TObject);
var
kv : TKeyVerifyParamsW;
i : integer;
dwResult : dword;
stemp : string;
sresult : string;
begin
if eUserInfo.Text = '' then
begin
ShowMessage('User info field is empty!');
Exit;
end;
if mKey.Text = '' then
begin
ShowMessage('Key field is empty!');
Exit;
end;
kv.RegInfo := PWideChar(eUserInfo.Text);
kv.Key := PWideChar(mKey.Text);
kv.KeyLen := length(mKey.Text);
kv.UseHardwareLocking := cbHardwareID.Checked;
if kv.UseHardwareLocking then
begin
kv.HardwareID := PWideChar(eHardware.Text);
end;
dwResult := KG_VerifyRegistrationInfoFromProjectW('default.enigma', @kv);
if dwResult = EP_NO_ERROR then
begin
sresult := 'Key is valid!'#13#10;
sresult := format(sresult + 'Creation Date: %s'#13#10, [DateToStr(EncodeDate(kv.CreationYear, kv.CreationMonth, kv.CreationDay))]);
if kv.UseKeyExpiration then
begin
sresult := format(sresult + 'Expiration Date: %s'#13#10, [DateToStr(EncodeDate(kv.ExpirationYear, kv.ExpirationMonth, kv.ExpirationDay))]);
end;
if kv.UseRegisterAfter then
begin
sresult := format(sresult + 'Register After Date: %s'#13#10, [DateToStr(EncodeDate(kv.RegisterAfterYear, kv.RegisterAfterMonth, kv.RegisterAfterDay))]);
end;
if kv.UseRegisterBefore then
begin
sresult := format(sresult + 'Register Before Date: %s'#13#10, [DateToStr(EncodeDate(kv.RegisterBeforeYear, kv.RegisterBeforeMonth, kv.RegisterBeforeDay))]);
end;
if kv.UseCountyLimit then
begin
for i := 0 to length(KEY_COUNTRIES) - 1 do
begin
if kv.CountryCode = KEY_COUNTRIES[i].Code then
begin
stemp := KEY_COUNTRIES[i].Name;
break;
end;
end;
sresult := format(sresult + 'Locked to country: %s'#13#10, [stemp]);
end;
if kv.UseExecutionsLimit then
begin
sresult := format(sresult + 'Executions limit: %d executions'#13#10, [kv.ExecutionsCount]);
end;
if kv.UseDaysLimit then
begin
sresult := format(sresult + 'Days limit: %d days'#13#10, [kv.DaysCount]);
end;
if kv.UseRunTimeLimit then
begin
sresult := format(sresult + 'Run-time limit: %d minutes'#13#10, [kv.RunTimeMinutes]);
end;
if kv.UseGlobalTimeLimit then
begin
sresult := format(sresult + 'Global Time limit: %d minutes'#13#10, [kv.GlobalTimeMinutes]);
end;
for i := 1 to NUMBER_OF_CRYPTED_SECTIONS do
begin
if kv.EncryptedSections[i] then
begin
sresult := format(sresult + 'Unlocked section #%d'#13#10, [i]);
end;
end;
end else
begin
case dwResult of
EP_ERROR_UNKNOWN : sresult := 'EP_ERROR_UNKNOWN ';
EP_ERROR_KEYBUFFEREMPTY : sresult := 'EP_ERROR_KEYBUFFEREMPTY ';
EP_ERROR_KEYBUFFERISLESS : sresult := 'EP_ERROR_KEYBUFFERISLESS ';
EP_ERROR_REGINFOEMPTY : sresult := 'EP_ERROR_REGINFOEMPTY ';
EP_ERROR_REGINFOTOOLARGE : sresult := 'EP_ERROR_REGINFOTOOLARGE ';
EP_ERROR_PRIVATEKEYISNOTSET : sresult := 'EP_ERROR_PRIVATEKEYISNOTSET ';
EP_ERROR_PUBLICKEYISNOTSET : sresult := 'EP_ERROR_PUBLICKEYISNOTSET ';
EP_ERROR_PRIVATEKEYISINVALID : sresult := 'EP_ERROR_PRIVATEKEYISINVALID ';
EP_ERROR_PUBLICKEYISINVALID : sresult := 'EP_ERROR_PUBLICKEYISINVALID ';
EP_ERROR_KEYMODEISINVALID : sresult := 'EP_ERROR_KEYMODEISINVALID ';
EP_ERROR_KEYBASEISINVALID : sresult := 'EP_ERROR_KEYBASEISINVALID ';
EP_ERROR_CURRENTDATEISINVALID : sresult := 'EP_ERROR_CURRENTDATEISINVALID ';
EP_ERROR_EXPIRATIONDATEISINVALID : sresult := 'EP_ERROR_EXPIRATIONDATEISINVALID';
EP_ERROR_KEYISINVALID : sresult := 'EP_ERROR_KEYISINVALID ';
EP_ERROR_HARDWAREID : sresult := 'EP_ERROR_HARDWAREID ';
EP_ERROR_HARDWAREBUFFEREMPTY : sresult := 'EP_ERROR_HARDWAREBUFFEREMPTY ';
EP_ERROR_HARDWAREIDINVALIDFORKEY : sresult := 'EP_ERROR_HARDWAREIDINVALIDFORKEY';
EP_ERROR_PROJECTFILENOTFOUND : sresult := 'EP_ERROR_PROJECTFILENOTFOUND ';
EP_ERROR_INVALIDPROJECTFILE : sresult := 'EP_ERROR_INVALIDPROJECTFILE ';
EP_ERROR_EXECUTIONSNUMBERINVALID : sresult := 'EP_ERROR_EXECUTIONSNUMBERINVALID';
EP_ERROR_DAYSNUMBERINVALID : sresult := 'EP_ERROR_DAYSNUMBERINVALID ';
EP_ERROR_COUNTRYCODEINVALID : sresult := 'EP_ERROR_COUNTRYCODEINVALID ';
EP_ERROR_RUNTIMEINVALID : sresult := 'EP_ERROR_RUNTIMEINVALID ';
EP_ERROR_GLOBALTIMEINVALID : sresult := 'EP_ERROR_GLOBALTIMEINVALID ';
EP_ERROR_INSTALLBEFOREINVALID : sresult := 'EP_ERROR_INSTALLBEFOREINVALID ';
EP_ERROR_INSTALLAFTERINVALID : sresult := 'EP_ERROR_INSTALLAFTERINVALID ';
else sresult := 'Unknown error';
end;
end;
ShowMessage(sresult);
end;
Show/Hide Visual C++ function example void CKeygenDlg::OnBnClickedButtonverfp()
{
TODO: Add your control notification handler code here
TKeyVerifyParamsW kv;
wchar_t keybuffer[2048];
wchar_t username[255];
wchar_t hardwareid[255];
DWORD dwResult;
memset(&kv, 0, sizeof(kv));
memset(&keybuffer, 0, sizeof(keybuffer));
GetDlgItemTextW(IDC_EDITKEY, (wchar_t*)&keybuffer, sizeof(keybuffer));
kv.Key = (wchar_t*) keybuffer;
kv.KeyLen = wcslen(kv.Key);
memset(&username, 0, sizeof(username));
GetDlgItemTextW(IDC_EDITNAME, (wchar_t*)&username, sizeof(username));
kv.RegInfo = (wchar_t*)&username;
if (IsDlgButtonChecked(IDC_CHECKHD) != 0)
{
kv.UseHardwareLocking = true;
memset(&hardwareid, 0, sizeof(hardwareid));
GetDlgItemTextW(IDC_EDITHD, (wchar_t*)&hardwareid, sizeof(hardwareid));
kv.HardwareID = (wchar_t*)&hardwareid;
}
dwResult = KG_VerifyRegistrationInfoFromProjectW(L"default.enigma", &kv);
if (dwResult == EP_NO_ERROR)
{
wchar_t tmp[255];
wchar_t mes[2048] = L"Valid Registration Key!\n";
wsprintf(tmp, L"Creation date: %d/%d/%d\n", kv.CreationDay, kv.CreationMonth, kv.CreationYear);
wcscat(mes, tmp);
if (kv.UseKeyExpiration)
{
wsprintf(tmp, L"Expiration date: %d/%d/%d\n", kv.ExpirationDay, kv.ExpirationMonth, kv.ExpirationYear);
wcscat(mes, tmp);
}
if (kv.UseRegisterAfter)
{
wsprintf(tmp, L"Register After date: %d/%d/%d\n", kv.RegisterAfterDay, kv.RegisterAfterMonth, kv.RegisterAfterYear);
wcscat(mes, tmp);
}
if (kv.UseRegisterBefore)
{
wsprintf(tmp, L"Register Before date: %d/%d/%d\n", kv.RegisterBeforeDay, kv.RegisterBeforeMonth, kv.RegisterBeforeYear);
wcscat(mes, tmp);
}
if (kv.UseExecutionsLimit)
{
wsprintf(tmp, L"Executions: %d\n", kv.ExecutionsCount);
wcscat(mes, tmp);
}
if (kv.UseDaysLimit)
{
wsprintf(tmp, L"Days: %d\n", kv.DaysCount);
wcscat(mes, tmp);
}
if (kv.UseRunTimeLimit)
{
wsprintf(tmp, L"Run-time: %d minutes\n", kv.RunTimeMinutes);
wcscat(mes, tmp);
}
if (kv.UseGlobalTimeLimit)
{
wsprintf(tmp, L"Global Time: %d minutes\n", kv.GlobalTimeMinutes);
wcscat(mes, tmp);
}
if (kv.UseCountyLimit)
{
for (int i = 0; i < ARRAYSIZE(KEY_COUNTRIES); i++)
{
if (kv.CountryCode == KEY_COUNTRIES[i].Code)
{
wchar_t wcn[255];
char* acn = KEY_COUNTRIES[i].Name;
int aln = strlen(acn) + 1;
MultiByteToWideChar(CP_ACP, 0, acn, aln, (LPWSTR)&wcn, aln);
wsprintf(tmp, L"Country Lock: %s\n", &wcn);
wcscat(mes, tmp);
break;
}
}
}
for (int i = 0; i < NUMBER_OF_CRYPTED_SECTIONS; i++)
{
if (kv.EncryptedSections[i])
{
wsprintf(tmp, L"Unlocked section: #%d\n", i + 1);
wcscat(mes, tmp);
}
}
MessageBox(mes);
} else
{
wchar_t* sError;
switch (dwResult)
{
case EP_ERROR_UNKNOWN:
sError = L"EP_ERROR_UNKNOWN";
break;
case EP_ERROR_KEYBUFFEREMPTY:
sError = L"EP_ERROR_KEYBUFFEREMPTY";
break;
case EP_ERROR_KEYBUFFERISLESS:
sError = L"EP_ERROR_KEYBUFFERISLESS";
break;
case EP_ERROR_REGINFOEMPTY:
sError = L"EP_ERROR_REGINFOEMPTY";
break;
case EP_ERROR_REGINFOTOOLARGE:
sError = L"EP_ERROR_REGINFOTOOLARGE";
break;
case EP_ERROR_PRIVATEKEYISNOTSET:
sError = L"EP_ERROR_PRIVATEKEYISNOTSET";
break;
case EP_ERROR_PUBLICKEYISNOTSET:
sError = L"EP_ERROR_PUBLICKEYISNOTSET";
break;
case EP_ERROR_PRIVATEKEYISINVALID:
sError = L"EP_ERROR_PRIVATEKEYISINVALID";
break;
case EP_ERROR_PUBLICKEYISINVALID:
sError = L"EP_ERROR_PUBLICKEYISINVALID";
break;
case EP_ERROR_KEYMODEISINVALID:
sError = L"EP_ERROR_KEYMODEISINVALID";
break;
case EP_ERROR_KEYBASEISINVALID:
sError = L"EP_ERROR_KEYBASEISINVALID";
break;
case EP_ERROR_CURRENTDATEISINVALID:
sError = L"EP_ERROR_CURRENTDATEISINVALID";
break;
case EP_ERROR_EXPIRATIONDATEISINVALID:
sError = L"EP_ERROR_EXPIRATIONDATEISINVALID";
break;
case EP_ERROR_KEYISINVALID:
sError = L"EP_ERROR_KEYISINVALID";
break;
case EP_ERROR_HARDWAREID:
sError = L"EP_ERROR_HARDWAREID";
break;
case EP_ERROR_HARDWAREBUFFEREMPTY:
sError = L"EP_ERROR_HARDWAREBUFFEREMPTY";
break;
case EP_ERROR_HARDWAREIDINVALIDFORKEY:
sError = L"EP_ERROR_HARDWAREIDINVALIDFORKEY";
break;
case EP_ERROR_PROJECTFILENOTFOUND:
sError = L"EP_ERROR_PROJECTFILENOTFOUND";
break;
case EP_ERROR_INVALIDPROJECTFILE:
sError = L"EP_ERROR_INVALIDPROJECTFILE";
break;
case EP_ERROR_EXECUTIONSNUMBERINVALID:
sError = L"EP_ERROR_EXECUTIONSNUMBERINVALID";
break;
case EP_ERROR_DAYSNUMBERINVALID:
sError = L"EP_ERROR_DAYSNUMBERINVALID";
break;
case EP_ERROR_COUNTRYCODEINVALID:
sError = L"EP_ERROR_COUNTRYCODEINVALID";
break;
case EP_ERROR_RUNTIMEINVALID:
sError = L"EP_ERROR_RUNTIMEINVALID";
break;
case EP_ERROR_GLOBALTIMEINVALID:
sError = L"EP_ERROR_GLOBALTIMEINVALID";
break;
case EP_ERROR_INSTALLBEFOREINVALID:
sError = L"EP_ERROR_INSTALLBEFOREINVALID";
break;
case EP_ERROR_INSTALLAFTERINVALID:
sError = L"EP_ERROR_INSTALLAFTERINVALID";
break;
default:
sError = L"Unknown error";
break;
}
MessageBox(sError);
}
}
Show/Hide C# (.NET) function example private void btnVerifyFP_Click(object sender, EventArgs e)
{
if (tbUserInfo.Text == string.Empty)
{
MessageBox.Show("User info field is empty!");
return;
}
if (tbUserInfo.Text == string.Empty)
{
MessageBox.Show("Registration key field is empty!");
return;
}
Enigma_KeyGen_IDE.TKeyVerifyParamsW kv = new Enigma_KeyGen_IDE.TKeyVerifyParamsW();
kv.Key = tbKey.Text;
kv.KeyLen = tbKey.Text.Length;
kv.RegInfo = tbUserInfo.Text;
kv.UseHardwareLocking = cbHardware.Checked;
if (kv.UseHardwareLocking)
{
kv.HardwareID = tbHardware.Text;
}
uint dwResult = Enigma_KeyGen_IDE.KG_VerifyRegistrationInfoFromProjectW("default.enigma", ref kv);
string sout = string.Empty;
if (dwResult == Enigma_KeyGen_IDE.EP_NO_ERROR)
{
sout = "Valid key!\n";
sout = string.Format(sout + "Creation Date: {0}/{1}/{2}\n", kv.CreationDay, kv.CreationMonth, kv.CreationYear);
if (kv.UseKeyExpiration)
{
sout = string.Format(sout + "Expiration Date: {0}/{1}/{2}\n", kv.ExpirationDay, kv.ExpirationMonth, kv.ExpirationYear);
}
if (kv.UseRegisterAfter)
{
sout += string.Format("Register After: {0}/{1}/{2}\n", kv.RegisterAfterDay, kv.RegisterAfterMonth, kv.RegisterAfterYear);
}
if (kv.UseRegisterBefore)
{
sout += string.Format("Register Before: {0}/{1}/{2}\n", kv.RegisterBeforeDay, kv.RegisterBeforeMonth, kv.RegisterBeforeYear);
}
if (kv.UseCountyLimit)
{
Enigma_KeyGen_IDE ide = new Enigma_KeyGen_IDE();
foreach (Enigma_KeyGen_IDE.TKeyCountries country in ide.KEY_COUNTRIES)
{
if (country.Code == kv.CountryCode)
{
sout += string.Format("Country Lock: {0}\n", country.Name);
break;
}
}
}
if (kv.UseExecutionsLimit)
{
sout += string.Format("Executions: {0}\n", kv.ExecutionsCount);
}
if (kv.UseDaysLimit)
{
sout += string.Format("Days: {0}\n", kv.DaysCount);
}
if (kv.UseRunTimeLimit)
{
sout += string.Format("Runtime: {0}\n", kv.RunTimeMinutes);
}
if (kv.UseGlobalTimeLimit)
{
sout += string.Format("Global Time: {0}\n", kv.GlobalTimeMinutes);
}
for (int i = 0; i < Enigma_KeyGen_IDE.NUMBER_OF_CRYPTED_SECTIONS; i++)
{
if (Convert.ToBoolean(kv.EncryptedSections[i]))
{
sout = string.Format(sout + "Unlock section: #{0}\n", i + 1);
}
}
}
else
{
switch (dwResult)
{
case Enigma_KeyGen_IDE.EP_ERROR_UNKNOWN:
sout = "EP_ERROR_UNKNOWN";
break;
case Enigma_KeyGen_IDE.EP_ERROR_KEYBUFFEREMPTY:
sout = "EP_ERROR_KEYBUFFEREMPTY";
break;
case Enigma_KeyGen_IDE.EP_ERROR_KEYBUFFERISLESS:
sout = "EP_ERROR_KEYBUFFERISLESS";
break;
case Enigma_KeyGen_IDE.EP_ERROR_REGINFOEMPTY:
sout = "EP_ERROR_REGINFOEMPTY";
break;
case Enigma_KeyGen_IDE.EP_ERROR_REGINFOTOOLARGE:
sout = "EP_ERROR_REGINFOTOOLARGE";
break;
case Enigma_KeyGen_IDE.EP_ERROR_PRIVATEKEYISNOTSET:
sout = "EP_ERROR_PRIVATEKEYISNOTSET";
break;
case Enigma_KeyGen_IDE.EP_ERROR_PUBLICKEYISNOTSET:
sout = "EP_ERROR_PUBLICKEYISNOTSET";
break;
case Enigma_KeyGen_IDE.EP_ERROR_PRIVATEKEYISINVALID:
sout = "EP_ERROR_PRIVATEKEYISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_PUBLICKEYISINVALID:
sout = "EP_ERROR_PUBLICKEYISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_KEYMODEISINVALID:
sout = "EP_ERROR_KEYMODEISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_KEYBASEISINVALID:
sout = "EP_ERROR_KEYBASEISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_CURRENTDATEISINVALID:
sout = "EP_ERROR_CURRENTDATEISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_EXPIRATIONDATEISINVALID:
sout = "EP_ERROR_EXPIRATIONDATEISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_KEYISINVALID:
sout = "EP_ERROR_KEYISINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_HARDWAREID:
sout = "EP_ERROR_HARDWAREID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_HARDWAREBUFFEREMPTY:
sout = "EP_ERROR_HARDWAREBUFFEREMPTY";
break;
case Enigma_KeyGen_IDE.EP_ERROR_HARDWAREIDINVALIDFORKEY:
sout = "EP_ERROR_HARDWAREIDINVALIDFORKEY";
break;
case Enigma_KeyGen_IDE.EP_ERROR_PROJECTFILENOTFOUND:
sout = "EP_ERROR_PROJECTFILENOTFOUND";
break;
case Enigma_KeyGen_IDE.EP_ERROR_INVALIDPROJECTFILE:
sout = "EP_ERROR_INVALIDPROJECTFILE";
break;
case Enigma_KeyGen_IDE.EP_ERROR_EXECUTIONSNUMBERINVALID:
tbKey.Text = "EP_ERROR_EXECUTIONSNUMBERINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_DAYSNUMBERINVALID:
tbKey.Text = "EP_ERROR_DAYSNUMBERINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_COUNTRYCODEINVALID:
tbKey.Text = "EP_ERROR_COUNTRYCODEINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_RUNTIMEINVALID:
tbKey.Text = "EP_ERROR_RUNTIMEINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_GLOBALTIMEINVALID:
tbKey.Text = "EP_ERROR_GLOBALTIMEINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_INSTALLBEFOREINVALID:
tbKey.Text = "EP_ERROR_INSTALLBEFOREINVALID";
break;
case Enigma_KeyGen_IDE.EP_ERROR_INSTALLAFTERINVALID:
tbKey.Text = "EP_ERROR_INSTALLAFTERINVALID";
break;
default:
sout = "Unknown error";
break;
}
}
MessageBox.Show(sout);
}
See function examples in the installation folder, Examples\KeygenUnicode subfolder.
|
Show/Hide Delphi function definition