C on Neale's Corner

Expand/Collapse Animation with UWP

Tue, 27 Jul 2021 00:00:00 +0000

In my latest app I wanted to have an UI element that could expand and collapse on demand - it was taking up a lot of screen real estate and I wanted to give the user a choice of whether to minimise part of it. Hooking a button up to change the visibility of the block is straight forward enough, but I’d like to have a nice animation to go with it - perhaps with the UI element below sliding upwards to expand into the new space. This is what I wanted to achieve:

First I found a stackoverflow answer that did most of what I wanted - but the bottom block didn’t slide upwards. This is because the CompositeTransform.ScaleY property scales the control but does not change the boundaries - I found this out in this post on MSDN. The key information is here:

Scaling transforms affect how the UIElement is rendered but don’t change other properties such as Height: the Height will remain whatever it is, but the overall image’s display size is stretched or shrunk (in this case shrunk) by the ScaleY factor.

So, if we want to change the height of the shrinking block, we need to change the height, and this is where I found out about Dependent and Independent animations.

A dependent animation is one that will cause the Xaml to re-layout. Expensive; therefore requiring an “opt-in”.

https://stackoverflow.com/questions/10479903/how-to-animate-height-of-control-in-windows-8-xaml

So, putting this together in a Storyboard, I had the following XAML code:

        <Storyboard x:Name="TestShrink">
            <!-- this works but only if From is also set.  -->
            <DoubleAnimation
                EnableDependentAnimation="True"
                Storyboard.TargetName="info"
                Storyboard.TargetProperty="Height"
                From="100"
                To="0"
                Duration="0:0:1" />
        </Storyboard>

I ran this and nothing happened. Then I added a “From” property and it shrank just fine. This is in contrast to the notes in the Microsoft documentation:

**To only:**Â The animation progresses from the animated property’s base value or a previous animation’s output value to the value specified by theÂ ToÂ property.

https://docs.microsoft.com/en-us/uwp/api/Windows.UI.Xaml.Media.Animation.DoubleAnimation?view=winrt-20348

Clearly, the animation was not using the animated property’s base value as the starting value.

So, there was only one thing for it - to write this thing in code and retrieve/assign the height of the control programmatically. This, in C++/CX is what I ended up with as proof of concept code, and it should be reasonably easy to convert into C# or C++/WinRT if needed:

	// Configuration parameters.
	double animation_length_seconds = 5.0;
	FrameworkElement^ chevron = fiToggleShowConfig;
	FrameworkElement^ target = info;
	static double _openHeight = 0.0;

	// Create the storyboard.
	auto storyboard = ref new Windows::UI::Xaml::Media::Animation::Storyboard();

	double start_height = 0.0, end_height = 0.0;
	double start_opacity = 0.0, end_opacity = 0.0;
	double start_rotation = 0.0, end_rotation = 0.0;
	if (target->Visibility == Windows::UI::Xaml::Visibility::Visible) {
		_openHeight = target->ActualHeight;
		start_height = target->ActualHeight;
		end_height = 0.0;

		start_opacity = 1.0;
		end_opacity = 0.0;

		start_rotation = 0.0;
		end_rotation = 180.0;

		// Make the target collapsed at the end of the storyboard.
		{
			auto visible = ref new ObjectAnimationUsingKeyFrames();
			auto kf_start = ref new DiscreteObjectKeyFrame();
			KeyTime kt_start;
			TimeSpan ts_start;
			ts_start.Duration = 0;
			kt_start.TimeSpan = ts_start;
			kf_start->KeyTime = kt_start;
			kf_start->Value = Windows::UI::Xaml::Visibility::Visible;
			visible->KeyFrames->Append(kf_start);

			auto kf_end = ref new DiscreteObjectKeyFrame();
			KeyTime kt_end;
			TimeSpan ts_end;
			ts_end.Duration = (animation_length_seconds * 1000) * 1000;
			kt_end.TimeSpan = ts_end;
			kf_end->KeyTime = kt_end;
			kf_end->Value = Windows::UI::Xaml::Visibility::Collapsed;
			visible->KeyFrames->Append(kf_end);

			storyboard->SetTarget(visible, target);
			storyboard->SetTargetProperty(visible, "(UIElement.Visibility)");
			storyboard->Children->Append(visible);
		}

	} else {
		start_height = 0.0;
		end_height = _openHeight;

		start_opacity = 0.0;
		end_opacity = 1.0;

		start_rotation = 180.0;
		end_rotation = 0.0;

		// Make the target visible straight away.
		target->Visibility = Windows::UI::Xaml::Visibility::Visible;
	}

	// Shrinking the info size.
	{
		auto shrink = ref new DoubleAnimation();
		shrink->From = start_height;
		shrink->To = end_height;

		TimeSpan ts = TimeSpan();
		ts.Duration = (long long) ((animation_length_seconds * 1000) * 1000);
		shrink->Duration = ts;
		shrink->EnableDependentAnimation = true;

		storyboard->SetTargetProperty(shrink, "Height");
		storyboard->SetTarget(shrink, target);
		storyboard->Children->Append(shrink);
	}

	// Reducing the Opactity of the info.
	{
		auto hide = ref new DoubleAnimationUsingKeyFrames();
		auto start = ref new EasingDoubleKeyFrame();
		KeyTime kt;
		TimeSpan start_ts;
		start_ts.Duration = 0;
		kt.TimeSpan = start_ts;
		start->KeyTime = kt;
		start->Value = start_opacity;
		hide->KeyFrames->Append(start);

		auto end = ref new EasingDoubleKeyFrame();
		TimeSpan end_ts;
		end_ts.Duration = (animation_length_seconds * 1000) * 1000;
		KeyTime end_kt;
		end_kt.TimeSpan = end_ts;
		end->KeyTime = end_kt;
		end->Value = end_opacity;
		hide->KeyFrames->Append(end);
		
		storyboard->SetTarget(hide, target);
		storyboard->SetTargetProperty(hide, "(UIElement.Opacity)");
		storyboard->Children->Append(hide);
	}

	// Rotating the Chevron
	if (chevron != nullptr)
	{
		auto rotate = ref new DoubleAnimationUsingKeyFrames();

		auto kf_start = ref new EasingDoubleKeyFrame();
		KeyTime kt_start;
		TimeSpan ts_start;
		ts_start.Duration = 0;
		kt_start.TimeSpan = ts_start;
		kf_start->KeyTime = kt_start;
		kf_start->Value = start_rotation;
		rotate->KeyFrames->Append(kf_start);

		auto kf_end = ref new EasingDoubleKeyFrame();
		KeyTime kt_end;
		TimeSpan ts_end;
		ts_end.Duration = (animation_length_seconds * 1000) * 750;
		kt_end.TimeSpan = ts_end;
		kf_end->KeyTime = kt_end;
		kf_end->Value = end_rotation;
		rotate->KeyFrames->Append(kf_end);

		storyboard->SetTarget(rotate, chevron);
		storyboard->SetTargetProperty(rotate, "(UIElement.RenderTransform).(RotateTransform.Angle)");
		storyboard->Children->Append(rotate);
	}

	storyboard->Begin();

This can be easily compressed into a function for your needs, apologies that the naming scheme for variables isn’t consistent - this is very much proof of concept code written with kids running around !

This is the XAML that I have on the page:

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>

        <TextBlock
            Grid.ColumnSpan="2"
            Margin="10"
            FontSize="18"
            FontWeight="Bold">
            Text Header
        </TextBlock>

        <Grid x:Name="infogrid" Grid.Row="1">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="40" />
                <ColumnDefinition Width="500" />
            </Grid.ColumnDefinitions>

            <FontIcon
                x:Name="fiToggleShowConfig"
                Margin="10,10"
                HorizontalAlignment="Left"
                VerticalAlignment="Top"
                FontFamily="Segoe MDL2 Assets"
                Glyph="&#xE70D;"
                RenderTransformOrigin="0.5,0.5"
                Tapped="fiToggleShowConfig_Tapped">
                <FontIcon.RenderTransform>
                    <RotateTransform />
                </FontIcon.RenderTransform>
            </FontIcon>

            <TextBlock
                x:Name="info"
                Grid.Column="1"
                Margin="10"
                TextWrapping="Wrap">
                Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
                <TextBlock.RenderTransform>
                    <CompositeTransform />
                </TextBlock.RenderTransform>
            </TextBlock>

        </Grid>

        <TextBlock
            Grid.Row="2"
            Grid.ColumnSpan="2"
            Margin="10"
            FontSize="18"
            FontWeight="Bold">
            Another Title
        </TextBlock>

        <TextBlock
            Grid.Row="3"
            Grid.ColumnSpan="2"
            Margin="10"
            TextWrapping="Wrap">
            Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?
        </TextBlock>
</Grid>

The code is run when the fiToggleShowConfig control is tapped, and as the animation is dependent and running on the UI thread, nothing more can happen with the UI until it is complete - therefore you don’t have to handle a new animation being started before the current one is complete.

It does mean that everything else you need to run on the UI thread will be delayed until it is complete though.

vSphere REST API and C++ (Part 2)

Tue, 13 Jun 2017 00:00:00 +0000

This is the second part in an ongoing series looking at using the vSphere REST API and C++ with the cpp rest sdk (formerly known as “Casablanca”). In the first part we authenticated against SSO and got some information from the vCenter.

In this part we are going to refine our methods so that we can reuse our code. We will introduce some structs and functions that allow us to work with results.

Connecting

The first thing we are going to introduce is a struct that will manage our connection data. It is as follows:

struct vc_info {
  std::wstring server; // The address of the server
  std::wstring token; // The SSO token.

  http_client_config config; // The connection configuration
  credentials server_credentials; // Authentication credentials for the connection

  int last_status_code; // The last HTTP status code we received.
  std::string last_exception; // A text explanation of the last exception
};

All the members are annotated with how they will be used.

We will now assemble a ConnectAsync function which will return a task (and a pointer to a vc_info object). The code looks as follows:

task<shared_ptr<vc_info>> ConnectAsync(const wchar_t* server, const wchar_t* username, const wchar_t* password)
{
	std::shared_ptr<vc_info> pInfo = make_shared<vc_info>();
	pInfo->config.set_validate_certificates(false);
	pInfo->server_credentials = credentials(username, password);
	pInfo->config.set_credentials(pInfo->server_credentials);
	pInfo->server = server;

	http_client client(server, pInfo->config);
	http_request request(methods::POST);
	request.set_request_uri(U("/rest/com/vmware/cis/session"));

	return concurrency::create_task(client.request(request)).then([pInfo](http_response response) {
		// if status is OK then extract json.
		pInfo->last_status_code = response.status_code();
		return response.extract_json();

	}).then([pInfo](web::json::value v) {
		// get and set the token
		std::shared_ptr<vc_object> data = CheckJson(U(""), v);
		if (data) {
			std::shared_ptr<vc_property> value = get_object_property(data, L"value");
			if (value) {
				pInfo->token = value->s;
			}
		}

	}).then([pInfo](task<void> t) {
		// exception catching.
		try {
			t.get();

		}
		catch (const std::exception& e) {
			pInfo->last_exception = e.what();
			printf("Exception: %s\n", e.what());

		}

		return pInfo;
	});
}

As you can see,this function will wrap the call toÂ /rest/com/vmware/cis/session and provision our object to hold information about the “connection”.

It takes a server name, username and password and attempts to connect, returninf a vc_info object with completed information whether it is successful or not. The task chain is similar to what we wrote in part 1, with the exception that we now store the SSO token in the vc_info object. We will use a function “CheckJson” to format the result into an object hierarchy and we will be creating this in the next section.

This is how our ConnectAsync function can be used in a synchronous fashion.

`1`	`std::shared_ptr<vc_info> pInfo = ConnectAsync("my-vsphere.fqdn", L"administrator@vsphere.local", L"password").get();`

Handling JSON

As most calls will return information in a JSON format, we will use the following two structs to store and organise information.The CPP Rest SDK contains some JSON classes, so when we call

`1`	`return response.extract_json();`

on a response, we get a

`1`	`web::json::value`

object that we can use as we desire. We will transform this into our own objects -Â vc_property and vc_object, which are defined below.

struct vc_property {
	std::wstring name;
	int type;

	// unrestricted unions not working on MSVC mean s cannot be a member :(
	union {
		bool b;
		int i;
		double d;
	};

	std::wstring s;
};

struct vc_object {
	std::vector<std::shared_ptr<vc_property>> properties;

	std::shared_ptr<vc_object> parent;
	std::vector<std::shared_ptr<vc_object>> children;
};

As noted, as unrestricted unions were/are not supported on the version of Visual Studio I wrote this on, we exclude the variable “s” from the union. Possibly fixed or working in another complier thoughI haven’t checked.

We now need a function that we will call to extrapolate our JSON and structure it so we can use it. Because objects can contain other objects we may need to call this function recursively. The function takes the name of the key/value pair, the value and the parent object.

// Properties are automatically added to parent. Don't need to be returned.
// Objects are returned to be added to the children ..
std::shared_ptr<vc_object> CheckJson(utility::string_t name, web::json::value v, std::shared_ptr<vc_object> parent = nullptr)
{
	std::shared_ptr<vc_object> result = nullptr;

	if (v.is_array()) {
		for (unsigned int i = 0; i < v.size(); ++i) {
			std::shared_ptr<vc_object> obj = CheckJson(U(""), v[i], parent);
		}

	}
	else if (v.is_object()) {
		result = make_shared<vc_object>();

		web::json::object o = v.as_object();
		std::for_each(begin(o), end(o), [&result](std::pair<utility::string_t, web::json::value> item) {
			CheckJson(item.first, item.second, result);
		});

		if (parent != nullptr)
			parent->children.push_back(result);

	}
	else {
		std::shared_ptr<vc_property> prop = std::make_shared<vc_property>();
		prop->name = name;

		if (v.is_string()) {
			prop->s = v.as_string();

		}
		else if (v.is_integer()) {
			prop->i = v.as_integer();

		}
		else if (v.is_boolean()) {
			prop->b = v.as_bool();

		}
		else if (v.is_double()) {
			prop->d = v.as_double();

		}

		if (parent)
			parent->properties.push_back(prop);
	}

	return result;
}

Note: I believe the array code won’t work at this time - I haven’t worked with any arrays to test yet - we’ll take a look at this later. It will however, handle objects as children and fill in the properties as required.

As an example, when authenticating with ConnectAsync the following information is returned:

We deal with this data with the following code:

std::shared_ptr<vc_object> data = CheckJson(U(""), data);
if (data) {
	std::shared_ptr<vc_property> value = get_object_property(data, L"value");
	if (value) {
		pInfo->token = value->s;
	}
}

The code above should be fairly straight forward - the code will transform the result to a vc_object object called data, and we get the value of the key/value pair with the key of “value” and assign it to the pInfo->token member property.

We are still missing a “get_object_property” function to make the code work. As the code to walk object properties for a specific entry will be commonly used it has been pulled out into it’s own function. This is straight forward and below:

std::shared_ptr<vc_property> get_object_property(std::shared_ptr<vc_object>& obj, const wchar_t* name)
{
	std::shared_ptr<vc_property> result = nullptr;

	if (obj != nullptr && name != 0 && wcslen(name) > 0) {
		std::vector<std::shared_ptr<vc_property>>::iterator find_result = std::find_if(begin(obj->properties), end(obj->properties), [name](std::shared_ptr<vc_property> prop) {
			return (_wcsicmp(prop->name.c_str(), name) == 0);
		});

		if (find_result != end(obj->properties)) {
			result = *find_result;
		}
	}

	return result;
}

Tasks

To do things with the API I’ve written a generic function that can send requests - this is very basic at the moment. One of the ways we can improve this later is to allow for the passing of values in a POST request. The body of the function is below:

task<std::shared_ptr<vc_task>> SendRequestAsync(web::http::method method, std::shared_ptr<vc_info> pInfo, const wchar_t* uri)
{
	std::shared_ptr<vc_task> result = make_shared<vc_task>();
	result->pServer = pInfo;

	return concurrency::create_task([pInfo, uri, method]() {

		http_client client(pInfo->server, pInfo->config);
		http_request request(method);
		request.set_request_uri(uri);

		// We need to pass the token with the request.
		request.headers().add(U("vmware-api-session-id"), pInfo->token.c_str());

		return client.request(request);

	}).then([pInfo, result](http_response response) {
		pInfo->last_status_code = response.status_code();
		result->status_code = pInfo->last_status_code;
		return response.extract_json();

	}).then([result](web::json::value v) {
		// parse the result and store.
		result->data = CheckJson(U(""), v);

	}).then([result](task<void> t) -> std::shared_ptr<vc_task> {
		try {
			t.get();

		}
		catch (const std::exception& e) {
			printf("Get exception: %s.\n", e.what());
		}

		return result;
	});
}

The function takes:

The type of request - i.e. GET, POST, PUT, DELETE
The vc_info object for the server.
The URI to send the request to.

It will return a vc_task object that will contain the status code and the parsed JSON from the response body. The vc_task struct is defined as:

struct vc_task {
	std::weak_ptr<vc_info> pServer;
	int status_code;
	std::string exception;
	std::shared_ptr<vc_object> data;
};

Example

Now we’ve done all of this, we can put this together and try it out - we’ll get information about the hosts. This is the pertinent section of our code:

std::shared_ptr<vc_info> pInfo = ConnectAsync(vcenter_url.c_str(), admin_username.c_str(), admin_password.c_str()).get();
if (pInfo && pInfo->last_status_code == 200) {
	wprintf(L"Connected successfully to %s.\n", vcenter_url.c_str());

	// Get hosts.
	shared_ptr<vc_task> task_results = SendRequestAsync(methods::GET, pInfo, L"/rest/vcenter/host").get();
	if (task_results->status_code == 200) {
		// Do something with the hosts ...
		if (task_results->data) {
			printf("There are %d results.\n", task_results->data->children.size());

			for_each(begin(task_results->data->children), end(task_results->data->children), [](std::shared_ptr<vc_object> host) {
				std::shared_ptr<vc_property> host_name = get_object_property(host, L"name");
				if (host_name) {
					wprintf(L"Host discovered: %s\n", host_name->s.c_str());
				}
			});
		}
	}

} else {
	// Could not connect.
	if (pInfo) {
		printf("ConnectAsync request returned code %d.\n", pInfo->last_status_code);

	} else {
		printf("Unknown error - ConnectAsync did not return server information object.\n");

	}
}

When running this against my home lab (please ignore the different DNS domains :p) I get the following output:

The code is available at the github repo - github.com/nelons/vSphereRestApi - please try it out and give me any feedback you have :)

Next Time

Now we’ve tidied up our structure to allow reuse we’ll look at tags and getting relevant objects.

vSphere REST API and C++ (Part 1)

Fri, 27 Jan 2017 00:00:00 +0000

One of the new features in vSphere 6.5 is the vSphere REST API. I’ve usedÂ the Web Services SDK before and it has never appeared as elegant as other automation APIs I’ve worked with, so the introduction of this held a lot of promise.

I rarely see examples for REST services in C++ and as it’s my chosen language and I’ve occasionally used “cpprestsdk” (previously known as Casablanca) I wondered if I could put something together. This is the first article in a series playing around with what is possible.

We can browse the API by connecting to our local vCenter via the URL https:///apiexplorer/ and see what we can do.Â An overview of the process of a session is:

Send a POST request to /rest/com/vmware/cis/session and respond to the basic authentication request.
The responseÂ contains an authentication token which represents the session id.
For future requests pass the token in the headers as the value “vmware-api-session-id”.

The SDK and the reference guide for the REST API are available atÂ https://developercenter.vmware.com/web/sdk/65/vsphere-automation-rest.

The Code

The aim of this article is to show the authentication process and make a sample request.

This makes the authentication request:

web::http::client::http_client_config config;
config.set_validate_certificates(false);
credentials cred(U("administrator@vsphere.local"), "password");
config.set_credentials(cred);

http_client client(vcenter_url.c_str(), config);
uri_builder builder(U("/rest/com/vmware/cis/session"));

std::wstring token = L"";
create_task(client.request(methods::POST, builder.to_string())).then([](http_response response) {
  printf("SSO Request Response Status Code: %d\n", response.status_code());
  return response.extract_json();

}).then([&token](web::json::value v) {

  if (v.has_field(U("value"))) {
    json::value f = v.at(U("value"));
    token = f.as_string();
    wprintf(L"SSO Token value: %s.\n", f.as_string().c_str());
  }

}).then([](task t) {
  try {
    t.get();

  }
  catch (const std::exception& e) {
    printf("Exception: %s\n", e.what());

  }
}).wait();

if (token.length() > 0) {
  printf("Successfully authenticated against SSO.\n");
}

Most of the code above are is about how we use the cpprestsdk. The basic authentication response is handled by creating a credentials object and assigning it the configuration for our http_client. We also disable SSL certificate verification as we are using self signed certificates. If you are writing something for a secure environment then it’s probably a good idea not to do this ;)

The request is made at line 10 and the task returns the result in a json format (line 12). We then look for an entry with the name “value” and make a note of what it is set to - this is our token. The last part of the concurrency task chain is for handling any exceptions.

The code below will is an example request to vCenter that will use the newly retrieved session token.

web::http::client::http_client_config vc_config;
vc_config.set_validate_certificates(false);
http_client vc_client(vcenter_url.c_str(), vc_config);

uri_builder vc_vm_uri(U("/rest/vcenter/host"));

http_request vc_req(methods::GET);
vc_req.headers().add(U("vmware-api-session-id"), token.c_str());
vc_req.set_request_uri(vc_vm_uri.to_string());

create_task(vc_client.request(vc_req)).then([](http_response response) {
  printf("/rest/vcenter/host Request Status Code: %d\n", response.status_code());
  return response.extract_string();

}).then([](utility::string_t text) {
  printf("The response was:\n");
  wprintf(text.c_str());
  printf("\n");

}).wait();

The code above will create a request and pass the token as the “vmware-api-session-id” value. As can be seen, we are still disabling SSL certificate verification but we are not passing credentials - the session id is enough.

The request will be sent to “/rest/vcenter/host” (line 5), which retrieves information about the hosts added to the vCenter. Once the request is made, the output is printed out to the screen in the JSON format.

We could add a final task segment to catch any exceptions that occur in the chain - there is no particular reason for why it is missing.

An Example

Below is a screenshot of the output of the program - I’ve blanked out the address and password of my home lab, though you can see that after a successful authentication information about two hosts is returned.

Full Source

The source is available on GitHub - https://github.com/nelons/vSphereRestApi/tree/master/part1. It was written in Visual Studio 2015 Community Edition and uses the cpprestsdk nuget package (and has UNICODE enabled).

It is not optimised or efficient code, but is meant to be straight forward to read and understand for near beginners (as some understanding of concurrency task code is required).

Comments, suggestions or errors - please let me know !

LoadState not called in C++ Windows Store App

Mon, 14 Oct 2013 00:00:00 +0000

I had a problem recently where LoadState was not being called in my C++ based Windows Store App page that was based upon LayoutAwarePage.

This question from the Microsoft forums pointed me in the right direction - I had an OnNavigatedTo declared, this was being called and the LoadState was not. I moved the code from the OnNavigatedTo into LoadState and removed the former. Everything works again and I can now use Suspend/Resume properly on the page :)

C++ Windows 8 Store Apps: The series

Mon, 11 Mar 2013 00:00:00 +0000

So I’m going to start writing my own apps - I’ve been doing C++ for a while now (15 odd years) and fancy a new project to occupy my commute each day. I’ve equipped an old laptop with a cheap SSD and Windows 8 and installed Visual Studio. The SSD really makes a difference !

Some things I’ve noticed: - System Restore Protection was not enabled for drive C: out of the box. I suffered some registry corruption (old laptop) and had to rebuild because of this. - It took about an hour to build my refresh/reset image in case I suffered more problems. I really feel there should be UI elements advertising this feature.

I’ve been using it on my desktop (dual monitor) for a little while now, and while the base of the OS is good, it is hampered by a slightly unclear UI design. The ModernMix application that changes full screen Store apps to windowed apps is very welcome, but I still don’t like the number of clicks required to restart/shutdown, or that Control Panel/Preferences exists in two places.

Finally, some C++ and the class scope “internal”. I didn’t catch this in my first reading and it is essential to building your application. As you can’t have public class members which are not a Windows Runtime type, this is the only way of allowing classes to have accessible non-private members. For more information, see Namespaces and Type Visibility (C++/CX ) at MSDN.

Firefox information via DDE

Fri, 16 Mar 2012 00:00:00 +0000

For a while I’ve been looking into how to work out what browser URL’s a user has open with some code. Internet Explorer is easy - I’ll post that code later - but Firefox and others, that’s where it gets interesting.

From my searching there seems to be two ways to do this - DDE or by using looking through some child windows. This article isn’t going to tell you how to achieve this aim as I haven’t looked too closely at the second option but I have looked at the first and can write about it. But why ? for the sole reason that whilst trying to find this out I found many questions, but no clear answers and very little code. Everything in this article has been pieced together from the many to produce this one. Hopefully it will be helpful.

What really helped was finding this article, which referenced the NDde project (link) which allows DDE to be used in C#/etc. I’ve not dealt with DDE before, so it was all new to me but diving into the source code gave me pointers towards the correct part of MSDN - the DDE Management Library. From here I could start crafting a C++ solution that fitted my needs.

And this is where it all went wrong ! This link details how DDE works with Internet Explorer, but I have been unable to find a single official reference for Firefox. In particular are the topics WWW_GetWindowInfo and WWW_ListWindows - this would allow an application to get URL’s and information for each tab or browser window.

Problem is, Firefox doesn’t appear to support WWW_ListWindows and it doesn’t matter what parameter you pass to WWW_GetWindow, it only returns the active tab for the current window (and if no Firefox window is the active one, then the last window that was active). And what’s more, the return is in ANSI encoding rather than unicode. The string that is returned will give you the title of the window/tab/page in addition to the URL.

Here’s a win32 console application (compiles in VS210) that will return the one Firefox DDE result. Sorry about the lack of indenting, need to work out my code tags ;)

#include <Windows.h> #include <stdio.h> #include <conio.h>

void wmain(int argc, wchar_t** argv) { DWORD dwApp = 0;

if (DdeInitialize(&dwApp, NULL, APPCLASS_STANDARD, 0) != DMLERR_NO_ERROR) { return; }

HSZ server = DdeCreateStringHandle(dwApp, L"Firefox", CP_WINUNICODE); HSZ topic = DdeCreateStringHandle(dwApp, L"WWW_GetWindowInfo", CP_WINUNICODE);

HCONV conv = DdeConnect(dwApp, server, topic, NULL); if (conv == 0L) { DdeUninitialize(dwApp); return; }

HSZ url = DdeCreateStringHandle(dwApp, L"URL", CP_WINUNICODE);

HDDEDATA pData = DdeClientTransaction(NULL, 0, conv, url, CF_TEXT, XTYP_REQUEST, 500, NULL); if (pData == 0) { DdeUninitialize(dwApp); return; }

DWORD dwData = DdeGetData(pData, NULL, 0, 0); if (dwData > 0) { BYTE* p = (BYTE*) malloc(dwData); if (p != NULL) { DWORD dwRes = DdeGetData(pData, p, dwData, 0); if (dwRes > 0) { printf(“ANSI URL = %s,\n”, (char*) p); }

free(p); } }

DdeFreeStringHandle(dwApp, url); DdeFreeStringHandle(dwApp, server); DdeFreeStringHandle(dwApp, topic);

DdeDisconnect(conv);

DdeUninitialize(dwApp); _getch(); }

I’ll post how to get information from IE soon

\[which no doubt exists somewhere else on the web\]

and need to investigate more into getting information from windows classes. Right now it looks like the best and most reliable to get URL information would be to use a plugin.