/// <summary>Deactivate License button click event handler</summary> /// <param name="sender">object</param> /// <param name="e">EventArgs</param> private void deactivateButton_Click(object sender, EventArgs e) { if (!m_IsEvaluation) { if (m_License.DeactivateOnline()) { m_EvaluationLicense = new SampleSelfSignedLicense(); File.Delete(LicenseConfiguration.LicenseFilePath); if (m_EvaluationLicense.CreateExpiredEvaluation()) { m_CurrentLicense = m_EvaluationLicense; MessageBox.Show("The license has been deactivated successfully.", "License Deactivation", MessageBoxButtons.OK, MessageBoxIcon.Information); } else { MessageBox.Show("The license was not deactivated. Error: (" + m_License.LastError.ErrorNumber + ")" + m_License.LastError.ErrorString, "License Deactivation", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } } else { MessageBox.Show("The license was not deactivated. Error: (" + m_License.LastError.ErrorNumber + ")" + m_License.LastError.ErrorString, "License Deactivation", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } ReloadLicense(); } }
/// <summary>Refreshes the license file.</summary> /// <returns>Returns true if the license file was refreshed successfully. If false is returned, see the <see cref="License.LastError"/> property for details.</returns> internal bool RefreshLicense(XmlLicenseFileService webservice) { if (null == webservice) { LastError = new LicenseError(LicenseError.ERROR_WEBSERVICE_INVALID_CONFIGURATION); return(false); } string licenseContent = ""; if (!base.RefreshLicense(webservice, ref licenseContent)) { if (SampleLicense.ShouldLicenseBeRevoked(LastError.ExtendedErrorNumber)) { if (!RemoveLicense()) { return(false); } } return(false); } //try to save the license file to the file system if (!SaveLicenseFile(licenseContent)) { return(false); } return(true); }
/// <summary>Shows the <see cref="LicensingGui"/> object's license management form.</summary> private void ManageLicense() { if (LicenseConfiguration.EncryptionKey.LastError.ErrorNumber != LicenseError.ERROR_NONE && LicenseConfiguration.EncryptionKey.LastError.ErrorNumber != LicenseError.ERROR_PLUS_EVALUATION_WARNING) { m_License.LastError = LicenseConfiguration.EncryptionKey.LastError; } else if (SampleLicense.IsClockBackdatedAtRuntime(m_LastLicenseValidationTime)) { m_LastLicenseValidationResult = false; m_License.LastError = new LicenseError(LicenseError.ERROR_SYSTEM_TIME_INVALID); } else if (m_License.LastError.ErrorNumber != LicenseError.ERROR_COULD_NOT_LOAD_LICENSE) { m_LastLicenseValidationResult = m_License.Validate(); m_LastLicenseValidationTime = DateTime.UtcNow; statusLabel.Text = "Status: " + m_License.LastError.ErrorString; } this.criticalFeatureButton.Enabled = UpdateLicenseStatus(); sampleLicensingGui.ShowDialog(LicensingGuiDialog.LicenseManagement, this, FormStartPosition.CenterParent); //Update the status this.criticalFeatureButton.Enabled = UpdateLicenseStatus(); }
/// <summary>Displays <see cref="NetworkLicenseBrowseForm"/> Initializes licensing objects.</summary> private void InitializeLicensingObjects() { using (NetworkLicenseBrowseForm dialog = new NetworkLicenseBrowseForm()) { if (dialog.ShowDialog() == DialogResult.OK) { LicenseConfiguration.LicenseFilePath = dialog.SelectedPath; } else { Environment.Exit(0); } } //Initialize the license object. m_License = SampleLicense.CreateNewLicense(sampleLicensingGui); //Now pass the initialized license object to the LicenseingGui component. sampleLicensingGui.ApplicationLicense = m_License; //Configure the LicensingGui component with the trigger code seed data (only applicable with writable/self-signed licenses). sampleLicensingGui.TriggerCodeSeed = LicenseConfiguration.TriggerCodeSeed; sampleLicensingGui.RegKey2Seed = LicenseConfiguration.RegKey2Seed; //Wire-up event handlers for the LicensingGui component. Although this is typically done in the designer, this sample code intentionally //initializes to a) make it easier for you to copy-and-paste; and b) prevent the sample functions referenced here from being deleted when //the event handlers are changed in the designer. sampleLicensingGui.LicenseManagementActionComplete += new EventHandler <LicenseManagementActionCompleteEventArgs>(PostProcessingUpdates); sampleLicensingGui.ManualActionLoadRequested += new EventHandler <ManualActionLoadRequestedEventArgs>(ManualActionLoadRequested); sampleLicensingGui.ManualActionSaveRequested += new EventHandler <ManualActionSaveRequestedEventArgs>(ManualActionSaveRequested); sampleLicensingGui.SplashDoWork += new EventHandler <EventArgs>(InitializeApplicationSettings); sampleLicensingGui.SplashWorkCompleteEvent += new EventHandler <EventArgs>(SplashWorkCompleted); }
/// <summary>Reloads the license file and refreshes the status on the main form.</summary> /// <returns>bool</returns> public bool ReloadLicense() { m_License = new SampleLicense(); //Get the Evaluation Encryption envelope warning message. if (m_License.LastError.ErrorNumber == LicenseError.ERROR_PLUS_EVALUATION_WARNING) { m_WarningMessage = "Warning: (" + m_License.LastError.ErrorNumber + ") " + m_License.LastError.ErrorString; } bool successful = m_License.LoadFile(LicenseConfiguration.LicenseFilePath); if (!successful) { successful = m_License.CreateFreshEvaluation(); if (successful) { successful = m_License.LoadFile(LicenseConfiguration.LicenseFilePath); } } if (!successful) { mnuRefreshLicense.Enabled = false; UpdateLicenseStatusProperty(); SplashScreen.InitializeFeatures(m_Features, m_License, false); ToggleFeatures(); return(false); } return(RefreshLicenseStatus()); }
/// <summary>Refreshes the license file.</summary> /// <returns>Returns true if the license file was refreshed successfully. If false is returned, see the <see cref="License.LastError"/> property for details.</returns> internal bool RefreshLicense() { string licenseContent = ""; //initialize the object used for calling the web service method using (XmlLicenseFileService ws = m_Settings.CreateNewXmlLicenseFileServiceObject()) { if (null == ws) { LastError = new LicenseError(LicenseError.ERROR_WEBSERVICE_INVALID_CONFIGURATION); return(false); } if (!base.RefreshLicense(ws, ref licenseContent)) { if (SampleLicense.ShouldLicenseBeRevoked(LastError.ExtendedErrorNumber)) { RemoveLicense(); } return(false); } } //try to save the license file to the file system if (!SaveLicenseFile(licenseContent, false)) { return(false); } return(true); }
/// <summary>Reloads the license file and refreshes the status on the main form.</summary> public bool ReloadLicense() { m_License = new SampleLicense(); //Get the Evaluation Encryption envelope warning message. if (m_License.LastError.ErrorNumber == LicenseError.ERROR_PLUS_EVALUATION_WARNING) { m_WarningMessage = "Warning: (" + m_License.LastError.ErrorNumber + ") " + m_License.LastError.ErrorString; } bool successful = m_License.LoadFile(LicenseConfiguration.LicenseFilePath); SplashScreen.InitializeFeatures(m_Features, m_License, successful); this.mnuNew.Enabled = newToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.New.ToString()); this.mnuOpen.Enabled = openToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Open.ToString()); this.mnuPrint.Enabled = printToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Print.ToString()); this.mnuFind.Enabled = findToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Find.ToString()); this.mnuSave.Enabled = saveToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Save.ToString()); this.mnuSelectAll.Enabled = m_Features.CheckStatus(LicenseFeatures.SelectAll.ToString()); this.mnuCut.Enabled = cutToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Cut.ToString()); this.mnuCopy.Enabled = copyToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Copy.ToString()); this.mnuPaste.Enabled = pasteToolStripButton.Enabled = m_Features.CheckStatus(LicenseFeatures.Paste.ToString()); this.mnuSaveAs.Enabled = m_Features.CheckStatus(LicenseFeatures.SaveAs.ToString()); this.mnuReplace.Enabled = m_Features.CheckStatus(LicenseFeatures.Replace.ToString()); if (!successful) { m_IsLicenseValid = false; mnuRefreshLicense.Enabled = false; UpdateLicenseStatusProperty(); return(false); } return(RefreshLicenseStatus()); }
/// <summary>Performs post-processing updates.</summary> /// <remarks><para>This method handles the <see cref="LicensingGui.LicenseManagementActionComplete"/> event.</para></remarks> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> private void PostProcessingUpdates(object sender, LicenseManagementActionCompleteEventArgs e) { SampleLicense.PostProcessingUpdates(ref m_License, ref sampleLicensingGui, ref e, out m_LastLicenseValidationResult); m_LastLicenseValidationTime = DateTime.UtcNow; //Update the license status entries and the controls on this form. UpdateLicenseStatus(); }
/// <summary>Performs post-processing updates for actions performed through the <see cref="LicensingGui"/>.</summary> /// <remarks><para>This method is called by the <see cref="LicensingGui.LicenseManagementActionComplete"/> event handler method. In the /// sample application form source code (i.e. MainForm.cs), this method is similarly named PostProcessingUpdates. This might be named /// something like licensingGui1_LicenseManagementActionComplete in your application.</para></remarks> /// <param name="lic">The <see cref="License"/> being processed.</param> /// <param name="licGui">The <see cref="LicensingGui"/> used to process updates for the license.</param> /// <param name="e">The post-processing event arguments returned from the <see cref="LicensingGui"/> object.</param> /// <param name="newValidationSuccessful">Whether or not validation after processing updates has passed successfully.</param> internal static void PostProcessingUpdates(ref SampleLicense lic, ref LicensingGui licGui, ref LicenseManagementActionCompleteEventArgs e, out bool newValidationSuccessful) { //If an action was processed, run some post-processing actions. if (LicenseManagementActionTypes.ManualTriggerCode == e.ActionType) { //A trigger code needs to be processed... if (!lic.ProcessTriggerCode(e.LicenseID, e.Password, e.TriggerCodeNumber, e.TriggerCodeEventData)) { //If trigger code processing failed, show the error in the license management dialog. e.PostProcessingSuccessful = false; e.LastError = lic.LastError; } //Reload and revalidate the license file. if (lic.LoadFile(LicenseConfiguration.LicenseFilePath)) { newValidationSuccessful = lic.Validate(); } else { newValidationSuccessful = false; } } else if (LicenseError.ERROR_WEBSERVICE_RETURNED_FAILURE == e.LastError.ErrorNumber) { //The last action failed because the license is no longer valid in SOLO Server, so remove the license from the system. if (ShouldLicenseBeRevoked(lic.LastError.ExtendedErrorNumber)) { RevokeLicense(ref lic, ref licGui); newValidationSuccessful = false; } else { //The web service returned an error, which should be disabled to the user. e.PostProcessingSuccessful = false; e.LastError = lic.LastError; } } else if (LicenseManagementActionTypes.OnlineDeactivation == e.ActionType || LicenseManagementActionTypes.ManualDeactivation == e.ActionType) { RevokeLicense(ref lic, ref licGui); newValidationSuccessful = false; return; } else if (e.ProcessedSuccessfully && (LicenseManagementActionTypes.OnlineActivation == e.ActionType || LicenseManagementActionTypes.OnlineRefresh == e.ActionType || LicenseManagementActionTypes.ManualActivation == e.ActionType || LicenseManagementActionTypes.ManualRefresh == e.ActionType)) { //This was a successful activation or license refresh attempt, which means we have a new license to process. lic.ProcessNewLicense(ref e, out newValidationSuccessful); } newValidationSuccessful = lic.Validate(); }
/// <summary>Revokes the license.</summary> /// <remarks><para>This method is called from <see cref="PostProcessingUpdates"/>.</para></remarks> /// <param name="lic">The <see cref="License"/> object being revoked.</param> /// <param name="licGui">The <see cref="LicensingGui"/> which references the <see cref="License"/> object.</param> internal static void RevokeLicense(ref SampleLicense lic, ref LicensingGui licGui) { //The license has been revoked, so remove it from the system. lic.RemoveLicense(); //Create a new License to clear out any data (like the License ID and Installation ID) from memory. lic = SampleLicense.CreateNewLicense(licGui); //Now try to load the license file even though it doesn't exist. This helps ensure the correct error //message is displayed in the license status entry if the license management form is opened again. lic.LoadFile(LicenseConfiguration.LicenseFilePath); //Update the reference to the License object in case the license management form is opened again. licGui.ApplicationLicense = lic; }
/// <summary>Reloads the license file and refreshes the status on the main form.</summary> public void ReloadLicense() { m_License = new SampleReadOnlyLicense(); m_EvaluationLicense = new SampleSelfSignedLicense(); m_CurrentLicense = m_License; if (!m_License.LoadFile(LicenseConfiguration.LicenseFilePath)) { if (m_License.LastError.ErrorNumber == LicenseError.ERROR_PLUS_EVALUATION_INVALID) { //Invalid Protection PLUS 5 SDK evaluation envelope. statusTextLabel.Text = m_License.LastError.ErrorString; activateButton.Enabled = false; activateManuallyButton.Enabled = false; refreshLicenseButton.Enabled = false; deactivateButton.Enabled = false; return; } m_CurrentLicense = m_EvaluationLicense; m_IsEvaluation = true; if (!m_EvaluationLicense.LoadFile(LicenseConfiguration.LicenseFilePath)) { if (!m_EvaluationLicense.CreateFreshEvaluation()) { statusTextLabel.Text = "Invalid. " + m_License.LastError.ErrorString; return; } else { if (!m_EvaluationLicense.LoadFile(LicenseConfiguration.LicenseFilePath)) { statusTextLabel.Text = "Invalid. " + m_License.LastError.ErrorString; return; } } } } else { m_CurrentLicense = m_License; m_IsEvaluation = false; } RefreshLicenseStatus(); }
/// <summary>The method that performs the work, which is run asynchronously by the splash screen.</summary> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> /// <remarks><para>This method handles the <see cref="LicensingGui.SplashDoWork"/> event.</para></remarks> private void InitializeApplicationSettings(object sender, EventArgs e) { //Load and initialize the license file. m_LastLicenseValidationResult = m_License.InitializeLicense(); //If License is initialized properly, display status. If we created a fresh evaluation, clear the prior error generated from being unable to load an existing license file. if (m_LastLicenseValidationResult && m_License.LastError.ErrorNumber == LicenseError.ERROR_COULD_NOT_LOAD_LICENSE) { m_License.LastError = new LicenseError(LicenseError.ERROR_NONE); } //this.criticalFeatureButton.Enabled = UpdateLicenseStatus(); if (m_Semaphore != null) { m_Semaphore.Close(); m_Semaphore = null; } if (!m_LastLicenseValidationResult && !(m_License.IsWritable) && m_License.ProductOption.OptionType == LicenseProductOption.ProductOptionType.DownloadableLicenseWithTriggerCodeValidation) { //The license is a downloadable license file, and is not supported since the application license is not a WritableLicense... try { //Try to delete the downloadable file. File.Delete(LicenseConfiguration.LicenseFilePath); //Re-initialize the settings and the license objects so none of the information from the downloadable license carries over. m_License = SampleLicense.CreateNewLicense(sampleLicensingGui); sampleLicensingGui.ApplicationLicense = m_License; //Try to load and initialize the license file again. m_LastLicenseValidationResult = m_License.InitializeLicense(); } catch (Exception ex) { statusLabel.Text = "Error: " + ex.Message; } } m_LastLicenseValidationTime = DateTime.UtcNow; }
/// <summary>The method that performs the work, which is run asynchronously by the splash screen.</summary> /// <remarks><para>This method handles the <see cref="LicensingGui.SplashDoWork"/> event.</para></remarks> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> private void InitializeApplicationSettings(object sender, EventArgs e) { //Load and initialize the license file. m_LastLicenseValidationResult = m_License.InitializeLicense(); //If we created a fresh evaluation, clear the prior error generated from being unable to load an existing license file. if (m_LastLicenseValidationResult && m_License.LastError.ErrorNumber == LicenseError.ERROR_COULD_NOT_LOAD_LICENSE) { m_License.LastError = new LicenseError(LicenseError.ERROR_NONE); } if (!m_LastLicenseValidationResult && !(m_License.IsWritable) && m_License.ProductOption.OptionType == LicenseProductOption.ProductOptionType.DownloadableLicenseWithTriggerCodeValidation) { //The license is a downloadable license file, and is not supported since the application license is not a WritableLicense... string licenseFilePath = (File.Exists(LicenseConfiguration.VolumeLicenseFilePath) ? LicenseConfiguration.VolumeLicenseFilePath : LicenseConfiguration.LicenseFilePath); try { //Try to delete the downloadable file. File.Delete(licenseFilePath); //Re-initialize the settings and the license objects so none of the information from the downloadable license carries over. m_License = SampleLicense.CreateNewLicense(sampleLicensingGui); sampleLicensingGui.ApplicationLicense = m_License; //Try to load and initialize the license file again. m_LastLicenseValidationResult = m_License.InitializeLicense(); } catch (Exception) { //We were unable to delete the downloadable license file. } } m_LastLicenseValidationTime = DateTime.UtcNow; //TODO: If your application has any of its own initialization logic, you can add it here so it runs while the // splash screen is being displayed. }
/// <summary>Performs post-processing updates.</summary> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> /// <remarks><para>This method handles the <see cref="LicensingGui.LicenseManagementActionComplete"/> event.</para></remarks> private void PostProcessingUpdates(object sender, LicenseManagementActionCompleteEventArgs e) { SampleLicense.PostProcessingUpdates(ref m_License, ref sampleLicensingGui, ref e, out m_LastLicenseValidationResult); m_LastLicenseValidationTime = DateTime.UtcNow; //Update SeatsTotal when Semaphore is not null if (m_Semaphore != null) { m_Semaphore.SeatsTotal = m_License.LicenseCounter; if (m_Semaphore.SeatsAvailable < 0) { m_Semaphore.Close(); m_Semaphore = null; } } //Update license LastError if license activation has been completed successfully in post-Processing updates if (m_LastLicenseValidationResult && e.LastError.ErrorNumber == LicenseError.ERROR_NONE) { m_License.LastError = new LicenseError(LicenseError.ERROR_NONE); } UpdateLicenseStatus(); }
/// <summary>Main form Load event handler</summary> /// <param name="sender">object</param> /// <param name="e">EventArgs</param> private void MainForm_Load(object sender, EventArgs e) { using (NetworkLicenseBrowseForm browseDlg = new NetworkLicenseBrowseForm()) { if (browseDlg.ShowDialog() == DialogResult.OK) { LicenseConfiguration.LicenseFilePath = browseDlg.SelectedPath; } else { Application.Exit(); } } m_License = new SampleLicense(); if (m_License.LastError.ErrorNumber == LicenseError.ERROR_PLUS_EVALUATION_WARNING) { MessageBox.Show("Warning: (" + m_License.LastError.ErrorNumber + ") " + m_License.LastError.ErrorString, "Warning", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } ReloadLicense(); }
/// <summary>Occurs when a manual's action should be saved so it may be resumed later.</summary> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> /// <remarks> /// <para>This method handles the <see cref="LicensingGui.ManualActionSaveRequested"/> event.</para> /// <note type="caution"> /// <para> /// TODO: IMPORTANT: Either Implement your own handlers for loading and saving a manual request state/session, or update /// the ManualActionIV and ManualActionKey properties (in the LicenseConfiguration class) with randomized data which is /// unique for each of your applications. The implementations provided are simple and only designed to show you the /// functionality which you can achieve by saving and restoring manual action sessions. However, it is VERY IMPORTANT /// that you take measures to hide and protect the saved request data/file so users may not easily restore and replay /// old responses (known as a replay attack). /// </para> /// </note> /// </remarks> private void ManualActionSaveRequested(object sender, ManualActionSaveRequestedEventArgs e) { SampleLicense.SaveManualActionSessionState(e.Contents); }
/// <summary>Occurs when a manual action should be loaded and resumed.</summary> /// <param name="sender">The sender object.</param> /// <param name="e">Event arguments</param> /// <remarks> /// <para>This method handles the <see cref="LicensingGui.ManualActionLoadRequested"/> event.</para> /// <note type="caution"> /// <para> /// TODO: IMPORTANT: Either Implement your own handlers for loading and saving a manual request state/session, or update /// the ManualActionIV and ManualActionKey properties (in the LicenseConfiguration class) with randomized data which is /// unique for each of your applications. The implementations provided are simple and only designed to show you the /// functionality which you can achieve by saving and restoring manual action sessions. However, it is VERY IMPORTANT /// that you take measures to hide and protect the saved request data/file so users may not easily restore and replay /// old responses (known as a replay attack). /// </para> /// </note> /// </remarks> private void ManualActionLoadRequested(object sender, ManualActionLoadRequestedEventArgs e) { e.Contents = SampleLicense.LoadManualActionSessionState(); }
/// <summary>Updates the License's status in the <see cref="LicensingGui"/> and checks if network seats are available.</summary> /// <returns>Returns true if the network seats are not depleted, false otherwise</returns> private bool UpdateLicenseStatus() { SampleLicense license = SampleLicense.CreateNewLicense(sampleLicensingGui); license.LoadFile(LicenseConfiguration.LicenseFilePath); if (license.LicenseID != m_License.LicenseID || license.InstallationID != m_License.InstallationID) { sampleLicensingGui.ApplicationLicense = license; m_License = license; if (m_Semaphore != null) { m_Semaphore.Close(); m_Semaphore = null; } } if (!m_LastLicenseValidationResult || m_License.LastError.ErrorNumber != LicenseError.ERROR_NONE) { statusLabel.Text = m_License.GenerateNetworkLicenseStatusString(m_LastLicenseValidationResult, m_Semaphore); m_License.InitializeNetworkLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui, m_Semaphore); //Check seats count and set the status, when No seats available and license re-activation completed with errors(No activation left or Invalid License ID and/or Password). if (m_License.LastError.ErrorNumber == LicenseError.ERROR_WEBSERVICE_RETURNED_FAILURE && m_Semaphore == null) { m_Semaphore = new NetworkSemaphore(Path.GetDirectoryName(LicenseConfiguration.LicenseFilePath), LicenseConfiguration.NetworkSemaphorePrefix, m_License.LicenseCounter, true, 15, true); if (!m_Semaphore.Open() && m_Semaphore.LastError.ErrorNumber == LicenseError.ERROR_NETWORK_LICENSE_FULL) // try to open a network session { statusLabel.Text = m_License.GenerateLicenseStatusString(m_LastLicenseValidationResult) + "No Seats Available."; m_License.InitializeLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui); sampleLicensingGui.LicenseStatusEntries.Add(new LicenseStatusEntry(LicenseStatusIcon.Information, "Network Seats", "No Seats Available")); } m_Semaphore = null; } return(false); } if (!m_License.Validate()) { if (m_Semaphore != null) { m_Semaphore.Close(); // close our network session if it is open m_Semaphore = null; } statusLabel.Text = "The license is invalid or expired"; m_License.InitializeNetworkLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui, m_Semaphore); return(false); } else { if (m_Semaphore == null) { m_Semaphore = new NetworkSemaphore(Path.GetDirectoryName(LicenseConfiguration.LicenseFilePath), LicenseConfiguration.NetworkSemaphorePrefix, m_License.LicenseCounter, true, 15, true); m_Semaphore.Invalid += new NetworkSemaphore.InvalidEventHandler(InvalidSemaphoreHandler); if (!m_Semaphore.Open() && m_Semaphore.LastError.ErrorNumber == LicenseError.ERROR_NETWORK_LICENSE_FULL) // try to open a network session { using (NetworkLicenseSearchForm searchDialog = new NetworkLicenseSearchForm(m_Semaphore)) { if (searchDialog.ShowDialog() != DialogResult.OK) { statusLabel.Text = m_License.GenerateLicenseStatusString(m_LastLicenseValidationResult) + "No Seats Available."; m_License.InitializeLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui); sampleLicensingGui.LicenseStatusEntries.Add(new LicenseStatusEntry(LicenseStatusIcon.Information, "Network Seats", "No Seats Available")); m_Semaphore = null; } } } else if (m_Semaphore.LastError.ErrorNumber != LicenseError.ERROR_NONE) { statusLabel.Text = "Status: Unable to establish a network session. " + m_Semaphore.LastError; statusLabel.Text += "\nUsers: N/A"; m_Semaphore = null; } else { statusLabel.Text = m_License.GenerateNetworkLicenseStatusString(m_LastLicenseValidationResult, m_Semaphore); m_License.InitializeNetworkLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui, m_Semaphore); } return(false); } if (m_Semaphore != null && m_Semaphore.IsValid) { statusLabel.Text = m_License.GenerateNetworkLicenseStatusString(m_LastLicenseValidationResult, m_Semaphore); m_License.InitializeNetworkLicenseStatusEntries(m_LastLicenseValidationResult, sampleLicensingGui, m_Semaphore); } return(true); } }
/// <summary>Default main form constructor</summary> public MainForm() { InitializeComponent(); m_License = new SampleReadOnlyLicense(); m_CurrentLicense = m_License; }