Managed C++/CLI

LetsMond wrote:

how do I inform the main GUI thread that the worker thread has finished (the data is ready) so that it can update the GUI

MethodInvoker^ method = gcnew MethodInvoker(this, &YourForm::UpdateUI);
this->BeginInvoke(method);

LetsMond wrote:

The only method I know (used back before Managed C++/CLI) is to send a windows message from the worker thread. This is handled in the message loop of the main GUI thread and so the GUI can be updated.

SynchronizationContext^ context = SynchronizationContext::Current;
Thread^ t = gcnew Thread(gcnew ParameterizedThreadStart(this, &YourForm::Execute));
t->Start(context);

void Execute(Object^ obj)
{
    SynchronizationContext^ context = dynamic_cast<SynchronizationContext^>(obj);
    context->Post(gcnew SendOrPostCallback(this, &YourForm::UpdateUI), "Sample text");
}

void UpdateUI(Object^ obj)
{
   // your UI update code
}

LetsMond wrote:

However this feels a bit clunky to me and can cause problems when a dialog is open and the windows message is handled in the dialog's message loop and not that of the main application.

dybs wrote:

I believe the WorkerCompleted event executes on the thread that started the worker thread

LetsMond wrote:

My WorkerComplete event is not always being called from the main GUI thread

cherrymotion wrote:

I have no possiblity to change the incoming char-ptr
(because I get it sent on my interface).

Mark Salsbery
Microsoft MVP - Visual C++

int func1(const char *p)
{
   Form1::Console->AppendText("A");
   return 1;
}

1. Exposing a private variable violates OO rules. You should not expose the variable console to outside.
2. static keyword has a different implementation in managed world and it is not like the native implementation. In .NET, static variables will not be collected and will live until the application domain unloads.
3. Using Form1::Console is dangerous. When Form1 is never instantiated before this call, you will run into troubles.

santoshkaif wrote:

This variable argument function which receives the messages from library, displays it on the Console.

public ref class Form1 : public System::Windows::Forms::Form
{
    // other code

    public:

        // this returns a singleton instance of Form1. You need to use this whenever using Form1
	static Form1^ GetInstance()
	{
            if(instance == nullptr)
		instance = gcnew Form1();
            return instance;
	}

	void PrintValue(System::Object value)
	{
            Console->AppendText(value.ToString());
	}

    private:
        static Form1^ instance = nullptr;
        System::Windows::Forms::RichTextBox^ Console;
}

void WriteToScreen(int value)
{
   Form1^ form = Form1::GetInstance();
   form->PrintValue(value);
}

void WriteToScreen(double value)
{
   Form1^ form = Form1::GetInstance();
   form->PrintValue(value);
}

void func1(const char* p,...) 
{
	va_list variable_arguements;
	const char *temp;
	va_start(variable_arguements, p);
	int iValue;
	double dValue;
	for (temp = p; *temp; temp++) 
	{
		switch (*temp) 
		{
		case 'i':
			iValue = va_arg(variable_arguements, int);
			WriteToScreen(iValue);
			break;
		case 'd':
			dValue = va_arg(variable_arguements, double);
			WriteToScreen(dValue);
			break;
		default:
			// your code
			break;
		}
	}
	va_end(variable_arguements);
}

int main(array<System::String ^> ^args)
{
	Application::EnableVisualStyles();
	Application::SetCompatibleTextRenderingDefault(false); 

       Form1^ frm = Form1::GetInstance();
	Application::Run(frm);
	return 0;
}

library.h
--------------------
#ifndef _LIBRARY_H_
#define _LIBRARY_H_

void register_func(int(*pConsoleHandle)(const char* p, ...));
void library_message1(void);
void library_message2(void);
void library_message3(void);
void library_operation(void);

#endif	//_LIBRARY_H_

library.c
-----------------------
#include"library.h"
int(*pFuncHandle)(const char* p, ...);

void register_func(int(*pConsoleHandle)(const char* p, ...))
{
	pFuncHandle = pConsoleHandle;
}

void library_message1(void)
{
	pFuncHandle("Library msg1 is up!!");
}

void library_message2(void)
{
	char msg[] = "Library msg2";
	pFuncHandle("Library is up!!");
}

void library_message3(void)
{
	int i = 3;
	pFuncHandle("Library msg%d is up!!",i);
}

void library_operation(void)
{
	library_message1();
	library_message2();
	library_message3();
}

GUI_Application:
-----------------------
#pragma once
#include <stdio.h>
#include <stdarg.h>
#include "library.h"


namespace GUI_APP {

	using namespace System;
	using namespace System::ComponentModel;
	using namespace System::Collections;
	using namespace System::Windows::Forms;
	using namespace System::Data;
	using namespace System::Drawing;

	int DisplayMessage(const char* msg, ...);

	public ref class Form1 : public System::Windows::Forms::Form
	{
	public:
		Form1(void)
		{
			InitializeComponent();
			//
			//TODO: Add the constructor code here
			//
			register_func(DisplayMessage);
		}

	protected:
		~Form1()
		{
			if (components)
			{
				delete components;
			}
		}
	public: static System::Windows::Forms::RichTextBox^  Console;
	protected: 

	private:
		System::ComponentModel::Container ^components;

#pragma region Windows Form Designer generated code
		void InitializeComponent(void)
		{
			this->Console = (gcnew System::Windows::Forms::RichTextBox());
			this->SuspendLayout();
			// 
			// richTextBox1
			// 
			this->Console->Location = System::Drawing::Point(-2, -2);
			this->Console->Name = L"richTextBox1";
			this->Console->Size = System::Drawing::Size(296, 265);
			this->Console->TabIndex = 0;
			this->Console->Text = L"";
			// 
			// Form1
			// 
			this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
			this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
			this->ClientSize = System::Drawing::Size(292, 262);
			this->Controls->Add(this->Console);
			this->Name = L"Form1";
			this->Text = L"Form1";
			this->ResumeLayout(false);

		}
#pragma endregion

		void library_func(void)
		{
			library_operation();
		}
	};

	int DisplayMessage(const char* msg, ...)
	{
		int ret = 0;
		va_list ap;
		char *pBuffer = new char[256];

		//Display only if debug messages are enabled by application
		va_start(ap, msg);
		ret = vsprintf(pBuffer, msg, ap);

		GUI_APP::Form1::Console->AppendText(gcnew System::String((const char*)msg));

		delete(pBuffer);
		va_end(ap);

		return (ret);
	}

}

void PrintValue(String^ value)
{
    Console->AppendText(value);
}

void WriteToScreen(std::stringstream& value)
{
   // Constructing managed string from stringstream
   std::string str = stream.str();
   String^ managedString = gcnew String(str.c_str());

   Form1^ form = Form1::GetInstance();
   form->PrintValue(managedString);
}

void func1(const char* p,...) 
{
	const char *temp; int iValue; double dValue; bool percentageFound = false;
	va_list variable_arguements;
	va_start(variable_arguements, p);

	// string stream to hold the text to print
	std::stringstream stream;
	
	for (temp = p; *temp; temp++) 
	{
		if(*temp != '%' && !percentageFound)
			stream << *temp;
		else if(!percentageFound)
		{
			percentageFound = true;
			continue;
		}

		if(percentageFound)
		{
			switch (*temp) 
			{
			case 'd':
				iValue = va_arg(variable_arguements, int);
				stream << iValue;
				break;
			default:
				// your code
				break;
			}
			percentageFound = false;
		}
	}
	va_end(variable_arguements);
	WriteToScreen(stream);
}