Share on Facebook

1. Go to Control Panel and open Windows Firewall.

2. Click on Advanced Settings in the left panel.

3. In the Advanced Settings panel, click on Inbound Rules in the left column.

4. In the Inbound Rules window, click on New Rule in the right column.

5. In the New Inbound Rule Wizard, select Port and click next.

6. In the next window, select the port type (TCP) and enter the port numbers separated by a coma and click Next.

7. In the next window, select Block the Connection and click next.

8. Select all the domains you want to apply this rule to and click next.

9. Enter the name and description of the rule and click Finish. You are done!

Share on Facebook

The gcroot template is implemented using the facilities of the value class System::Runtime::InteropServices::GCHandle, which provides "handles" into the garbage-collected heap. Note that the handles themselves are not garbage collected and are freed when no longer in use by the destructor in the gcroot class (this destructor cannot be called manually). If you instantiate a gcroot object on the native heap, you must call delete on that resource.

The runtime will maintain an association between the handle and the CLR object, which it references. When the CLR object moves with the garbage-collected heap, the handle will return the new address of the object. A variable does not have to be pinned before it is assigned to a gcroot template.

Example

This sample shows how to create a gcroot object on the native stack.

// mcpp_gcroot.cpp

// compile with: /clr

#include <vcclr.h>

using namespace System;

class CppClass {

public:

   gcroot<String^> str;   // can use str as if it were String^

   CppClass() {}

};

int main() {

   CppClass c;

   c.str = gcnew String("hello");

   Console::WriteLine( c.str );   // no cast required

}

Output

hello

This sample shows how to create a gcroot object on the native heap.

// mcpp_gcroot_2.cpp

// compile with: /clr

// compile with: /clr

#include <vcclr.h>

using namespace System;

struct CppClass {

   gcroot<String ^> * str;

   CppClass() : str(new gcroot<String ^>) {}

   ~CppClass() { delete str; }

};

int main() {

   CppClass c;

   *c.str = gcnew String("hello");

   Console::WriteLine( *c.str );

}

Output

hello

This sample shows how to gcroot to hold references to value types (not reference types) in a native type by using gcroot on the boxed type.

// mcpp_gcroot_3.cpp

// compile with: /clr

#include < vcclr.h >

using namespace System;

public value struct V {

   String^ str;

};

class Native {

public:

   gcroot< V^ > v_handle;

};

int main() {

   Native native;

   V v;

   native.v_handle = v;

   native.v_handle->str = "Hello";

   Console::WriteLine("String in V: {0}", native.v_handle->str);

}

Output

String in V: hello

Read original article here.

Share on Facebook

It’s good to talk, so they say, and you know what? It’s good to share stuff too. Posting a few photos or a quick status update helps us stay connected with friends. Only trouble is, some people don’t know where to draw the line.

And there is most definitely a line. Some things just don’t need to be shared via your Facebook page – especially since it might not be just your friends that see your latest update. Depending on how tight your privacy settings are, your status updates, wall posts and photos could all be available for anyone to see, regardless of whether or not you have friended them.

With that in mind, here are our top 10 things you should never reveal when social networking: how many of these Facebook fails are you guilty of?

You are Having a Party

Larger image

Getty Images

Facebook is great for organising meet-ups with your mates, but listing your private house party on there? Unless you’re up for the kind of shindig that involves hundreds of gategrashers ripping up the carpet and making off with the family silver, we’d suggest not. To be honest, we would have thought people had wised up to this one by now but, judging by the recent case of a 16-year-old who listed his party on Facebook, it appears not.

You are off on a Holiday

Larger image

Microsoft

Time for a bit of sunshine? Good for you. You deserve it. Just try not to sign off for the fortnight with a status update along the lines of: "Yippee! Off to Spain for two weeks tomorrow!" It’s not that we’re jealous (honest), it’s just that putting that kind of information online is little better than slapping a "not home for a fortnight" poster on your front door. Even if you’ve taken the eminently sensible precaution of not including your address on your Facebook page, it can still be easily found elsewhere online.

You are Doing Great at Farmville

Larger image

Microsoft

Time for a reality check, farmers. We don’t care that you found a golden egg in your imaginary cowshed or that your pretend crops are growing super-great after being watered by that good friend of yours. In fact, people care so little, there are now even browser plug-ins available that will prevent Farmville updates from showing in Facebook feeds. If you’re going to skive through your day on Farmville or its ilk, fair enough. Just turn off the auto-updates, please?

You hate your Job

Larger image

Jesse Strigler Photography/Photographer’s Choice/Getty Images

Or your company, your boss or your customers. If you’re going to use your Facebook page as a vehicle for ranting about your daily occupation, you’d better make sure your privacy settings are ratcheted right up to the max or that you really don’t mind seeing your P45 pretty soon.

History is littered with the sackings of staff who made ill-advised comments about their workplace; from the airline staff who branded their passengers ‘chavs’ to the still-on-probation new starter who posted a foul-mouthed status update about her boss, forgetting she had previously friended him. Don’t join them.

You have 5000 friends on Facebook

Larger image

Microsoft

Some people collect Facebook ‘friends’ with the same kind of fervent desperation with which they court Twitter followers. But it’s all for nowt, as it turns out our poor brains can only deal with up to 150 real mates. Any more than that and you might find that while you’re bang up-to-date with what your window cleaner Steve’s weekend entails, your closest friend since childhood has become, um, thingummy. Remember, folks: a hulking friends list isn’t a sign of popularity, it’s just poor quality control.

You have done something Stupid

Larger image

Practical jokes are all well and good, but just remember that some people might not see the funny side. Ask the seven staff from the accident and emergency department at Great Western Hospital in Swindon, Wiltshire, who found themselves temporarily suspended after allegedly playing the ‘lying down game’ and posting the pictures on Facebook. The doctors and nurses were said to have photographed themselves lying on resuscitation trolleys, ward floors and a helipad, a prank of which bosses at the hospital took a rather dim view.

You are having an Affair

Larger image

Hannes Hepp/Photonica/Getty Images

Facebook has become fertile ground for divorce lawyers, who are more than happy to pore over the site searching for indiscreet status updates and incriminating photos. A recent Stateside survey of the American Academy of Matrimonial Lawyers found that 81% of top US divorce lawyers have seen an increase in cases using social networking evidence – with the bulk of those involving Facebook.

You are on the run

Larger image

Microsoft

For every criminal mastermind, there are a thousand bungling goons. Want proof? Look no further than 28-year-old Craig Lynch, a convicted burglar who went on the run after absconding from a Suffolk open prison in September 2009. Presumably feeling rather smug about evading the law, Lynch taunted police by regularly updating his Facebook page with details of what he was up to. Surprisingly, he managed to remain at large for a few months, before being finally reunited with his cell in January. Top tip for other would-be Lord Lucans: the idea is to lie low, understand?

You are on Jury Duty

Larger image

Microsoft

There are a few rules to abide by when sitting on a jury, but one of the real biggies is that you keep your mouth firmly zipped when outside the courtroom. As for posting about the case on your Facebook page, well that’s definitely right out.

Don’t put yourself in the position of one female juror, who was struggling to come to a decision on a child abuse case in 2008. "I don’t know which way to go, so I’m holding a poll," the erstwhile juror wrote on her Facebook page. Her removal from the jury swiftly followed, after an anonymous tip-off to court officials.

You are planning to pull a Sickie

Larger image

K2 Photography/Brand X Pictures/Getty Image

Most of us know the feeling when the alarm clock goes off and the first thought to amble into our foggy brain is, "I just can’t be bothered today". The occasional sickie can be one of life’s great pleasures but, again, it’s best kept to yourself rather than broadcast on Facebook. That is, if you want to keep your job.

A famous example involved Aussie call centre worker Kyle Doyle, who became a minor web celebrity after being memorably busted for skiving, after announcing his intention to pull a sickie on his Facebook status.

Original article appeared here.

Share on Facebook

In this Matlab GUI Tutorial, you will learn how to use radio buttons, toggle buttons and the button group panel.

Radio buttons and Toggle buttons are used exactly the same way that check boxes are used in Matlab GUIs, so we won’t go over how to use them. But there is one special case that needs to be covered. When either radio buttons or toggle buttons are used in conjunction with the button group panel, they exhibit mutually exclusive behavior. Simply put, this means that only one radio button or one toggle button can be selected at a time. This behavior can come in very useful for some GUIs. Since radio buttons and toggle buttons are identical in their functionality, what is said about one, is true for the other. Thus, only radio buttions will be discussed from here on out.

In this part of the tutorial, we will create a button group that will allow you to choose between different font sizes for the display text.

1. The first thing we need to do is to add a Button Panel component to the GUI figure that we were just working with. So if you closed GUIDE, reopen it again. Once you have GUIDE opened again, click on and add one Button Panel component to the GUI figure. Make sure it’s large enough to fit in three radio buttons. Next, click on and add three radio buttons onto the button group panel.

2. Double click on the first Radio Button component to bring up the Property Inspector. Change the String property to 8. Change the Tag property to fontsize08_radiobutton.

   

   Next, double click on the second Radio Button component, and change the String property to 12, and change the Tag property to fontsize12_radiobutton.

   Next, double click on the third Radio Button component, and change the String property to 16, and change the Tag property to fontsize16_radiobutton.

   Finally, double click on the button group panel and change the Tag property to fontSelect_buttongroup. You should also change the String property for the button group panel to Fontsize.

3. Here’s what your figure should look like after you add the components and modify them.

   

4. Before we move on, we should check the hierarchical structure of the GUI figure. Click on the icon and the followinging should appear:

   

   Make sure that the three radio buttons are one hierarchy below the button group icon.

5. Add the following line of code to the opening function. In this tutorial example, it is named button_tutorial_OpeningFcn function. Yours will be the name of the file you saved it as, followed by “_OpeningFcn”.

   set(handles.fontSelect_buttongroup,'SelectionChangeFcn',@fontSelect_buttongroup_SelectionChangeFcn);

   Make sure the previous line was added right before the line:

   guidata(hObject, handles);

   Next, add the following function at the very end of the .m file.

   function fontSelect_buttongroup_SelectionChangeFcn(hObject, eventdata)   %retrieve GUI data, i.e. the handles structure
   handles = guidata(hObject);   switch get(eventdata.NewValue,'Tag')   % Get Tag of selected object
       case 'fontsize08_radiobutton'
         %execute this code when fontsize08_radiobutton is selected
         set(handles.display_staticText,'FontSize',8);   case 'fontsize12_radiobutton'
         %execute this code when fontsize12_radiobutton is selected
         set(handles.display_staticText,'FontSize',12);   case 'fontsize16_radiobutton'
         %execute this code when fontsize16_radiobutton is selected
         set(handles.display_staticText,'FontSize',16);
       otherwise
          % Code for when there is no match.   end
   %updates the handles structure
   guidata(hObject, handles);

6. Notice that the callback functions for the radio buttons were not automatically generated by Matlab. This is completely normal. Each time a button is selected within the Button Group Panel component, the function defined within the SelectionChangeFcn property of Button Group Panel component is called. The line of code that was added in the opening function specifies the callback function when a button within the button group is selcted. The selection change function is then defined at the end of the .m file.

7. Now that we’ve completed both the visual and code aspects of the GUI, its time to run the GUI again. Try clicking on all of the buttons to make sure they perform their function correctly. Specifically, make sure that the font size changes accordingly.

   

And that’s it. Those are the basics of using the different buttons within the Matlab GUI.

Share on Facebook

In some programs, you may need to represent a list of items that share some characteristics. You can declare as many variables as necessary to represent such items. Here is an example of 5 numbers declared in a program:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int number1 = 266;
    int number1 = -4683;
    int number1 = -364;
    int number1 = 1450;
    int number1 = 8;

    Console::WriteLine();
    return 0;
}

If you want to use a group of objects that are of the same kind, C++ allows you to identify them as one variable. An array is a group of variables that shared the same characteristics.

Note:

Arrays in Managed C++ are a little different than those traditionally used in C++ because the Microsoft .NET Framework introduced a new way of declaring and using arrays, which also has to do with inherited classes. Because this can be a long and arduous subject, we will use arrays only as they are used and implemented in managed classes.

Array Declaration

An array is a group of values of the same kind or the same data type. Because the items are considered in a group, they are declared as one variable but the declaration must indicate that the variable represents various items. The items that are part of the group are also referred to as members of the array. To declare an array, you must give it a name.

In C++, the formula to declare an array is

DataType ArrayName[Dimension];

With this formula, an array would be declared as a value type. C++’ arrays can be declared either on the stack as in the above formula or on the heap. Managed C++ formally introduces the idea of declaring an array on the heap. Based on this, (most) arrays in Managed C++ are referred to as managed arrays. In this case, the formula to declare a managed array is:

DataType ArrayName[] = new DataType[Dimension];

Another equivalent formula is:

DataType ArrayName __gc[] = new DataType __gc[Dimension];

Therefore, the declaration of a managed array starts by specifying a data type, the DataType in our syntax. This indicates the kind of values shared by the members of the array. It also specify the amount of memory space that each member of the array will need to store its value. Like any other variable, an array must have a name, which is the ArrayName in our syntax. The name of the array must be followed by an opening and a closing square brackets "[]". To indicate that you are declaring a managed array, you must assign the same data type as a managed type, using the new keyword. Once again, the data type must be followed by square brackets. This time, inside of the square brackets, you must type the number of items that the array is made of; that is the Dimension in our syntax.

To create a managed array, the data type can be a normal C/C++ data type such as int, double, or .NET value type such as Int32, Double, etc. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number[] = new Double[5];

    Console::WriteLine(S"");
    return 0;
}

To re-enforce the idea of declaring a managed array, you can optionally type the __gc keyword to the left of the square brackets. You can type it either on only one side of the assignment operator or on both sides. Therefore, the following declarations are equivalents:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number1[]      = new Double[5];
    Double Number2 __gc[] = new Double[5];
    Double Number3[]      = new Double __gc[5];
    Double Number4 __gc[] = new Double __gc[5];

    Console::WriteLine();
    return 0;
}

When declaring a managed array, you must use the new operator to indicate to the compiler that the variable would be declared on the heap. Because the new operator is explicit enough, you can omit the __gc keyword. Also, you don’t have to perform the whole declaration at the same time but you must have requested that memory be allocated to the array before it can be used. Based on this, you can first declare the variable with the left part of the assignment operator. Then, when you are ready, you can allocate memory to the variable and specify the number of members of the array. When doing this, type the name of the variable without the square brackets and type the right side of our syntax. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    Console::WriteLine();
    return 0;
}

We mentioned that, when declaring the array, you should specify the number of members of the array with the Dimension in our syntax. After declaring the array, if you want, you can reduce or increase the number of items by simply performing a new assignment to the variable and indicating the new desired Dimension. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    // The new dimension of the array
    number = new Double[8];

    Console::WriteLine();
    return 0;
}

Initializing an Array

When declaring an array, before using it, we saw that you must specify the number of members of the array. This declaration allocates an amount of memory space to the variable. The first member of the array takes a portion of this space. The second member of the array occupies memory next to it:

Array Variable

Member1

Member2

Member3

Member4

Member5

Each member of the array can be accessed using its position. The position is also referred to as an index. The members of an array are arranged starting at index 0, followed by index 1, then index 2, etc. This system of counting is referred to as "zero-based" because the counting starts at 0. To locate a member, type the name of the variable followed by an opening and a closing square brackets. Inside the bracket, type the zero-based index of the desired member. After locating the desired member of the array, you can assign it a value, exactly as you would any regular variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"");
    return 0;
}

In the same way, you can retrieve the value of a member of an array based on its index. Such a value can be displayed to the user as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"Value 1: {0}", __box(number[0]));
    Console::WriteLine(S"Value 2: {0}", __box(number[1]));
    Console::WriteLine(S"Value 3: {0}", __box(number[2]));
    Console::WriteLine(S"Value 4: {0}", __box(number[3]));
    Console::WriteLine(S"Value 5: {0}", __box(number[4]));

    number = new Double[8];

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

When it comes to initializing a managed array, you don’t have to access each member of the array and initialize them individually. That technique is used if you don’t yet have the values of the items at the time you are declaring the array. If you know the values of the members of the managed array at the time you are declaring its variable, you can declare and initialize the whole array at the same time. The formula you would use is:

DataType VariableName __gc[] = { Values Separated By Commas };

This formula is almost the same used in C/C++ with one difference. If you omit the __gc keyword, the array would be a regular one as used in C/C++. The alternative is to type the __gc keyword to the left of the square brackets. If you do this, two features would automatically be applied to your array. First, the array would be garbage collected, that is, cleaned up by the garbage collector; therefore becoming a managed array. Second, the array becomes automatically derived from the .NET’s Array class, which gives it access to the properties and methods of that class.

If you use the formula we used earlier with the number variable, the data type must be a .NET value type such as Int32, Double, Single, etc. If you use the above formula to declare and initialize your array, the data type can be a regular C/C++ type (such as int, long, or double) or a .NET value type (such as Int32 or Double). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    double number __gc[] = { 79.31, 47.59, 749.75, 9.07, 9.44 };

    Console::WriteLine(S"Value 1:  {0}", __box(number[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  79.31
Value 2:  47.59
Value 3:  749.75
Value 4:  9.07
Value 5:  9.44

Press any key to continue

Multidimensional Arrays

Introduction

The arrays we have used so far are referred to as single or one-dimensional arrays because they use a single group of items that can classified in a single column. In some cases, you may want to divided the list in two or more sections. For example, here is a list of numbers divided in various columns:

Sunday

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

Week 1

1

2

3

4

5

6

7

Week 2

8

9

10

11

12

13

14

Week 3

15

16

17

18

19

20

21

Week 4

22

23

24

25

26

27

28

A multi-dimensional array is one that still includes items of the same type but the group is made of sub-divisions following an arrangement an arrangement of your choice.

Two-Dimensional Arrays

Imagine you create two lists of items declared in two variables as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number1 __gc[] = new Double __gc[5];
    Double number2 __gc[] = new Double __gc[5];

    number1[0] = 643.18;
    number1[1] = 9.64;
    number1[2] = -48.05;
    number1[3] = 14.26;
    number1[4] = 62.55;

    number2[0] = 124.45;
    number2[1] = -62.84;
    number2[2] = 508.06;
    number2[3] = 92.68;
    number2[4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number1[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number1[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number1[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number1[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number1[4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number2[0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number2[1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number2[2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number2[3]));
    Console::WriteLine(S"Value 10: {0}", __box(number2[4]));

    Console::WriteLine(S"");
    return 0;
}

Instead of having two lists that represent the same types of values, you can declare a single array variable and divide its list of items in two. A two-dimensional array is an array made of two lists of items of the same data type. To declare a two-dimensional array, use the following formula:

DataType ArrayName[,] = new DataType[Dimension1,Dimension2];

Once again, you can optionally type the __gc keyword to the left of square brackets. The square brackets to the left of the assignment operator must have only a comma. Inside of the square brackets to the right side of the assignment, you must specify two numbers separated by a comma. The first number indicates the number of lists that the array contains. For a two-dimensional array, this number must be 2. The right value indicates the number of items that each list would contain. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    Console::WriteLine(S"");
    return 0;
}

In this case, the number variable is a two-dimensional array. In other words, the variable represents two lists. Each list contains 5 numbers.

To access a member of the array, type the name of the variable followed by the square brackets. Inside of the brackets, type the zero-based index of the desired list. The first list has an index of 0 while the second list has an index of 1. Then type the comma. On the right side of the comma, type the zero-based index of the member you want to access. Once you have accessed a member of the array, you can either assign it a value or retrieve the value it is currently holding. Here are examples:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    number[0,0] = 643.18;
    number[0,1] = 9.64;
    number[0,2] = -48.05;
    number[0,3] = 14.26;
    number[0,4] = 62.55;

    number[1,0] = 124.45;
    number[1,1] = -62.84;
    number[1,2] = 508.06;
    number[1,3] = 92.68;
    number[1,4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number[0,0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[0,1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[0,2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[0,3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[0,4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number[1,0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number[1,1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number[1,2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number[1,3]));
    Console::WriteLine(S"Value 10: {0}", __box(number[1,4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  643.18
Value 2:  9.64
Value 3:  -48.05
Value 4:  14.26
Value 5:  62.55
Value 6:  124.45
Value 7:  -62.84
Value 8:  508.06
Value 9:  92.68
Value 10: -44.82

Press any key to continue

Multi-Dimensional Arrays

A multi-dimensional array is a list of a list of a list, etc. In other words, it is a list that contains other lists while these other lists may contain other lists. For example, a three-dimensional array is one that contains 3 lists; each of the 3 lists contains a certain number of lists; then each list inside contains a list of items.

To declare a multi-dimensional array, in the square brackets, type the number of comma minus the total number of lists. For example, the square brackets of a three-dimensional array would have 2 commas. The square brackets of a 5-dimensional array would have 4 commas. In the square brackets on the right side of the assignment operator must indicate the dimension of each level of list. Consider the following declaration:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double hoursWorked __gc[,,] = new Double[6,3,5];

    Console::WriteLine();
    return 0;
}

In this declaration, the variable represents 6 lists. Each of the 6 lists is made of its own 3 lists. Each of the 3 lists contains 5 items. Another ways to illustrate this is that the array represents 6 months work for a contractor. In each of the six months, the contractor worked for 3 weeks. In each of the 3 weeks, the contractor worked for 5 days.

You can access each member of a multi-dimensional array using its index. In the above example, the first month has an index of 0 while the third month has an index of 2. Everything else is as done for the other dimensional arrays.

The String as an Array and Characters

An Array of Characters

In C/C++, you can declare a string variable as an array of characters. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";

    Console::Write("School Name: ");
    Console::WriteLine(School);

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences

Press any key to continue

In various previous examples, we used the .NET’s String class to declare and process string variables. In some cases, you will need access to one character inside of a string. In C/C++, if you declare a string using an array of characters as done above, to access an individual character, you type the name of the variable followed by square brackets. Inside of the square brackets, you can type the 0-based index of the character you want to access. Remember that the C/C++ char data type is an 8-bit value (to access a character, you should use its Char or __wchar_t type). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";
    Char First    = School[0];
    Char Second   = School[9];
    Char Third    = School[20];
    Char Fourth   = School[31];
    Char Fifth    = School[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences
Abbreviation: ACCIS

Press any key to continue

The Characters of a String Class Value

Many libraries that feature a string class, such as the ATL’s basic_string class, the MFC’s CString class, or the VCL’s AnsiString class provide you the same mechanism (by overloading the [] operator). The Microsoft .NET Framework’s String class provides a different functionality. If you declare a String variable and want to access any of its characters, the String class provides a Chars property that uses square brackets to locate a character. This is done using the same approach as above except that you must call the Chars property. Here is an example of how this can be done:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    String* School = "American College of Computer & Information Sciences";
    Char First    = School->Chars[0];
    Char Second   = School->Chars[9];
    Char Third    = School->Chars[20];
    Char Fourth   = School->Chars[31];
    Char Fifth    = School->Chars[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

It would produce the same result.

Arrays and Functions

An Array as Argument

An array can be passed to a function as argument. An array can also be returned by a function. To specify that a function takes an array as argument, declare the function as you would do for any regular function. In the parentheses of the function, declare the array with the __gc keyword as you have done so far. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When implementing the function, proceed as you would do normally. If you want to access the members of the array, use the same technique we have used so far, accessing each member of the array by its index. When you call the function from another function, simply pass the name of the array as argument. This would be done as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[]= { 643.18, 9.64, 48.05, 14.26, 62.55 };

    ShowNumbers(number);

    Console::WriteLine(S"");
    return 0;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

If you create a function that takes a non-managed array as argument, you usually would pass an additional argument that carries the size of the array. On the other hand, if you create a function that takes a managed array as argument, since the array would inherit from the Array class, the argument would automatically carry its dimension from the Length property of the Array class. Therefore, with a managed array as argument, you don’t have to specify the number of members to the function; the compiler would figure that out.

Returning an Array

Whether in C/C++ or Managed C++, an array is (always) passed as a reference. Although in C/C++, there is no formal way to return an array from a function, because an array is passed as a reference, it is very easy to return an array. Actually, this technique is used in C++ as an accessory, not as a means. Managed C++ formal features the idea of returning an array from a function. Although this is a new feature not available in C/C++, it is very easy to use, so easy that there is very little effort to implement this valuable addition.

To indicate that a function would return an array, if you are only declaring the function, type empty square brackets between the function’s parentheses and its semi-colon. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When defining the function, type the square brackets between the function’s parentheses and its opening curly bracket. In the body of the function, you can declare an array, do what you want with it, and then return it as the return value of the function.

When calling a function that returns an array, proceed with the rules you would use for any other function. For example, you can call the function in another and use it as you see fit. You can also assign the function to an array variable in order to initialize the variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double no __gc[] = GetNumbers();
    ShowNumbers(no);

    Console::WriteLine(S"");
    return 0;
}

Double GetNumbers()[]
{
    Double number[] = { 643.18, 9.64, 48.05, 14.26, 62.55 };

    return number;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

Share on Facebook

Tutorial

This tutorial is divided into the following sections:

• Arrays in General
• Declaring Arrays
• Initializing Arrays
• Accessing Array Members
• Arrays are Objects
• Using foreach with Arrays

Arrays in General

C# arrays are zero indexed; that is, the array indexes start at zero. Arrays in C# work similarly to how arrays work in most other popular languages There are, however, a few differences that you should be aware of.

When declaring an array, the square brackets ([]) must come after the type, not the identifier. Placing the brackets after the identifier is not legal syntax in C#.

int[] table; // not int table[];  

Another detail is that the size of the array is not part of its type as it is in the C language. This allows you to declare an array and assign any array of int objects to it, regardless of the array’s length.

int[] numbers; // declare numbers as an int array of any size
numbers = new int[10];  // numbers is a 10-element array
numbers = new int[20];  // now it's a 20-element array

Declaring Arrays

C# supports single-dimensional arrays, multidimensional arrays (rectangular arrays), and array-of-arrays (jagged arrays). The following examples show how to declare different kinds of arrays:

Single-dimensional arrays:

int[] numbers;

Multidimensional arrays:

string[,] names;

Array-of-arrays (jagged):

byte[][] scores;

Declaring them (as shown above) does not actually create the arrays. In C#, arrays are objects (discussed later in this tutorial) and must be instantiated. The following examples show how to create arrays:

Single-dimensional arrays:

int[] numbers = new int[5];

Multidimensional arrays:

string[,] names = new string[5,4];

Array-of-arrays (jagged):

byte[][] scores = new byte[5][];
for (int x = 0; x < scores.Length; x++)
{
   scores[x] = new byte[4];
}

You can also have larger arrays. For example, you can have a three-dimensional rectangular array:

int[,,] buttons = new int[4,5,3];

You can even mix rectangular and jagged arrays. For example, the following code declares a single-dimensional array of three-dimensional arrays of two-dimensional arrays of type int:

int[][,,][,] numbers;

Example

The following is a complete C# program that declares and instantiates arrays as discussed above.

// arrays.cs
using System;
class DeclareArraysSample
{
    public static void Main()
    {
        // Single-dimensional array
        int[] numbers = new int[5];

        // Multidimensional array
        string[,] names = new string[5,4];

        // Array-of-arrays (jagged array)
        byte[][] scores = new byte[5][];

        // Create the jagged array
        for (int i = 0; i < scores.Length; i++)
        {
            scores[i] = new byte[i+3];
        }

        // Print length of each row
        for (int i = 0; i < scores.Length; i++)
        {
            Console.WriteLine("Length of row {0} is {1}", i, scores[i].Length);
        }
    }
}

Output

Length of row 0 is 3
Length of row 1 is 4
Length of row 2 is 5
Length of row 3 is 6
Length of row 4 is 7

Initializing Arrays

C# provides simple and straightforward ways to initialize arrays at declaration time by enclosing the initial values in curly braces ({}). The following examples show different ways to initialize different kinds of arrays.

Note   If you do not initialize an array at the time of declaration, the array members are automatically initialized to the default initial value for the array type. Also, if you declare the array as a field of a type, it will be set to the default value null when you instantiate the type.

Single-Dimensional Array

int[] numbers = new int[5] {1, 2, 3, 4, 5};
string[] names = new string[3] {"Matt", "Joanne", "Robert"};

You can omit the size of the array, like this:

int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};

You can also omit the newoperator if an initializer is provided, like this:

int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};

Multidimensional Array

int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };

You can omit the size of the array, like this:

int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };

You can also omit the newoperator if an initializer is provided, like this:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

Jagged Array (Array-of-Arrays)

You can initialize jagged arrays like this example:

int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

You can also omit the size of the first array, like this:

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

-or-

int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

Notice that there is no initialization syntax for the elements of a jagged array.

Accessing Array Members

Accessing array members is straightforward and similar to how you access array members in C/C++. For example, the following code creates an array called numbers and then assigns a 5 to the fifth element of the array:

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
numbers[4] = 5;

The following code declares a multidimensional array and assigns 5 to the member located at [1, 1]:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
numbers[1, 1] = 5;

The following is a declaration of a single-dimension jagged array that contains two elements. The first element is an array of two integers, and the second is an array of three integers:

int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}
};

The following statements assign 58 to the first element of the first array and 667 to the second element of the second array:

numbers[0][0] = 58;
numbers[1][1] = 667;

Arrays are Objects

In C#, arrays are actually objects. System.Array is the abstract base type of all array types. You can use the properties, and other class members, that System.Array has. An example of this would be using the Lengthproperty to get the length of an array. The following code assigns the length of the numbers array, which is 5, to a variable called LengthOfNumbers:

int[] numbers = {1, 2, 3, 4, 5};
int LengthOfNumbers = numbers.Length;

The System.Array class provides many other useful methods/properties, such as methods for sorting, searching, and copying arrays.

Using foreach on Arrays

C# also provides the foreach statement. This statement provides a simple, clean way to iterate through the elements of an array. For example, the following code creates an array called numbers and iterates through it with the foreach statement:

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};
foreach (int i in numbers)
{
   System.Console.WriteLine(i);
}

With multidimensional arrays, you can use the same method to iterate through the elements, for example:

int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in numbers)
{
   Console.Write("{0} ", i);
}

The output of this example is:

9 99 3 33 5 55

However, with multidimensional arrays, using a nested for loop gives you more control over the array elements.

Share on Facebook

If you need the basic concepts about Ribbon Control, read the first part of my previous post.

1. Download the Ribbon Control binaries here.

2. Create a Windows Forms Visual Studio Project.

3. Add reference to the downloaded System.Windows.Forms.Ribbon.dll

4. Declare a System.Windows.Forms.Ribbon reference in Designer.cs file of your form and create an object (you also need to add some more supporting code). Be sure to include System.Windows.Forms to your code. Your .Designer.cs file should look somewhat like this;

using System.Windows.Forms;

namespace DMProject

{

    partial class Form1

    {

        /// <summary>

        /// Required designer variable.

        /// </summary>

        private System.ComponentModel.IContainer components = null;

        private System.Windows.Forms.Ribbon ribbon1 = null;

        /// <summary>

        /// Clean up any resources being used.

        /// </summary>

        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>

        protected override void Dispose(bool disposing)

        {

            if (disposing && (components != null))

            {

                components.Dispose();

            }

            base.Dispose(disposing);

        }

        #region Windows Form Designer generated code

        /// <summary>

        /// Required method for Designer support - do not modify

        /// the contents of this method with the code editor.

        /// </summary>

        private void InitializeComponent()

        {

            this.ribbon1 = new System.Windows.Forms.Ribbon();

            this.SuspendLayout();

            // 

            // ribbon1

            // 

            // 

            // Form1

            // 

            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);

            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;

            this.ClientSize = new System.Drawing.Size(284, 262);

            this.Controls.Add(this.ribbon1);

            this.Name = "Form1";

            this.Text = "Form1";

            this.ResumeLayout(false);

        }

        #endregion

    }

}

Your Windows Form Should look like this;

From this point onward, adding controls to the ribbon should be easy.

5. To add a tab to your ribbon control, click ‘Add Tab’. I have added three tabs; Home, Data Manipulation and Visualization. As with any control, you can change the properties of the tabs using the properties grid.

You can now compile and run the application, it would look like the screenshot above.

6. The next step is to add a panel to contain the buttons. To do this, click the ‘Add Panel’ button. Change the properties of the panels as desired.

7. Once the panels have been created, click a panel. The property grid shows options for the panel. Besides ‘Add Button’, these options include ‘Add Button List’, ‘Add Item Group’, ‘Add Separator’ etc. Click the ‘Add Button’ command. A button is created. You can use the property grid to set the text, tool tip and image for the button.

To add images to these buttons, you first have add the PNG images to your project resources. To do this, right click on your project and click Properties. In the resources tab, select ‘Add Existing File’ and browse for your PNG icons.

Congratulations! you have successfully added a ribbon control to your Windows Forms Application. You are good to go!

Share on Facebook

Image Courtesy MSDN.

The WPF team is sharing new WPF Ribbon control starting on Monday, October 27, 2008! Binaries and source code for the Ribbon can be downloaded at the Office UI Licensing site.

So, your first step is to go to Office UI Licensing site and get yourself a free WPF ribbon control. You must accept and sign license (it’s not a big deal) and download free WPF ribbon control. Just follow this link.

What is Ribbon Control?

Ribbons are the modern way to help users find, understand, and use commands efficiently and directly—with a minimum number of clicks, with less need to resort to trial-and-error, and without having to refer to Help.

The preview version of the WPF Ribbon includes many of the features which Independent Software Vendors (ISVs) need to add a Ribbon control to their WPF applications. Ribbon is a command bar that organizes a program’s features into a series of tabs at the top of a window. The Ribbon UI was designed by Microsoft Office to increase discoverability of features and functions, enable quicker learning of the program as a whole, and make users feel more in control of their experience with the program. The Ribbon is designed to replace the traditional menu bar and toolbars. The WPF Ribbon will include all of the basic Ribbon features and functionality, including tabs, groups, controls (buttons, split buttons, galleries, etc.), title bar integration of the application menu button and quick access toolbar, and resizing with dynamic layout.

For more information, follow this link.

Step 1: Adding The Ribbon Control to your WPF Application

1. Create a new WPF Project using Visual Studio .NET 2008.

2. Add a reference to “RibbonControlsLibrary.dll” that you downloaded earlier.

3. Add the XAML Reference to the DLL you have just added to your project by adding this line to your XAML code.

xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

4. Change the root element of your XAML code to r:RibbonWindow instead of Window.

   1: <r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

   5:     Title="Window1" Height="300" Width="300">

   6:     <Grid>

   7:         

   8:     </Grid>

   9: </r:RibbonWindow>

5. Add the r:Ribbon tag to your XAML code.

<r:Ribbon Title="WPF Ribbon - Document1" x:Name="ribbon" />

Your XAML code should now look like this;

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="300" Width="300">

    <Grid>

       <r:Ribbon Title="WPF Ribbon - Document1" x:Name="ribbon" />

    </Grid>

</r:RibbonWindow>

Congratulations! you have successfully added a ribbon control to your WPF application. Before you can see the control you would need to make a few changes to the accompanying cs file. Open the cs and add the following library and make sure that the partial class inherits from RibbonWindow instead of Window.

using Microsoft.Windows.Controls.Ribbon;

Compile and run the application to see the results.

Step 2: Adding Tabs, Groups and Buttons

As described earlier a ribbon control contains different tabs, each tab contains a groups and groups in turn contain buttons. In this step we would create tabs, groups and buttons.

1. To add tabs to your ribbon control add the r:RibbonTab tag within the r:Ribbon tag you added in the last step.

<r:RibbonTab Label="Home">

</r:RibbonTab><r:RibbonTab Label="Insert">

</r:RibbonTab><r:RibbonTab Label="Help">

</r:RibbonTab>

 

<r:RibbonGroup Name="Clipboard"></r:RibbonGroup><r:RibbonGroup Name="Fonts"></r:RibbonGroup>

<r:RibbonButton ></r:RibbonButton>

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="300" Width="300">

    <Grid>

        <r:Ribbon Title="Window1" x:Name="ribbon">

            <r:RibbonTab Label="Home">

                <r:RibbonGroup Name="Clipboard">

                    <r:RibbonButton ></r:RibbonButton>

                </r:RibbonGroup>

                <r:RibbonGroup Name="Fonts">

                    <r:RibbonButton ></r:RibbonButton>

                </r:RibbonGroup>

            </r:RibbonTab>

            <r:RibbonTab Label="Insert">

            </r:RibbonTab>

            <r:RibbonTab Label="Help">

            </r:RibbonTab>

        </r:Ribbon>

    </Grid>

</r:RibbonWindow>

Step 3: Adding Commands to Ribbon Groups and Ribbon Buttons

<r:RibbonWindow.Resources><ResourceDictionary></ResourceDictionary></r:RibbonWindow.Resources>

<r:RibbonCommand x:Key="ClipboardGroupCommand"CanExecute="OnCanExecute"Executed="OnShowClipboardGroup"LabelTitle="Clipboard"/>

<r:RibbonGroup Name="Clipboard">

<r:RibbonGroup Name="Clipboard" HasDialogLauncher="True" Command="{StaticResource ClipboardGroupCommand}">

Now, we have connected our resource with RibbonGroup. I have added HasDialogLauncher=”True” because that will allow us to fire OnShowClipboardGroup  event when user clicks on dialog launcher.

5. Go to your CS code-behind file and add these lines:

private void OnCanExecute(object target, CanExecuteRoutedEventArgs args){args.CanExecute = true;}

private void OnShowClipboardGroup(object target, ExecutedRoutedEventArgs args){MessageBox.Show("This is the Clipboard!.", "Clipboard Dialog");}

In principal we are done with this step and the essential concepts have been learnt. You can now learn your application and test to see that the message box is displayed.

Similar to step 4 and 5 create another RibbonCommand, add the resource to the Copy Button and write the corresponding cs code.

Creating another RibbonCommand;

<r:RibbonCommandx:Key="CopyCommand"CanExecute="OnCanExecute"Executed="OnCopyCommand"LabelTitle="Copy"LargeImageSource="Images\copy.png"ToolTipTitle="Copy (Ctrl+C)"ToolTipDescription="Copies the selected content on to the clipboard"></r:RibbonCommand>

<r:RibbonButton Name="Copy" Command="{StaticResource CopyCommand}"></r:RibbonButton>

private void OnCopyCommand(object target, ExecutedRoutedEventArgs args){    MessageBox.Show("This is the copy button!.", "Copy Dialog");}

<r:RibbonWindow x:Class="FirstRibbonApplication.Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:r="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"

    Title="Window1" Height="600" Width="400">

    <r:RibbonWindow.Resources>

        <ResourceDictionary>

            <r:RibbonCommand x:Key="ClipboardGroupCommand"

                             CanExecute="OnCanExecute"

                             Executed="OnShowClipboardGroup"

                             LabelTitle="Clipboard">

            </r:RibbonCommand>

            <r:RibbonCommand

                x:Key="CopyCommand"

                CanExecute="OnCanExecute"

                Executed="OnCopyCommand"

                LabelTitle="Copy"

                LargeImageSource="Images\copy.png"

                ToolTipTitle="Copy (Ctrl+C)"

                ToolTipDescription="Copies the selected content on to the clipboard">

            </r:RibbonCommand>

        </ResourceDictionary>

    </r:RibbonWindow.Resources>

    <Grid  HorizontalAlignment="Stretch" VerticalAlignment="Top">

        <r:Ribbon Title="Window1" x:Name="ribbon"  VerticalAlignment="Top">

            <r:RibbonTab Label="Home">

                <r:RibbonGroup Name="Clipboard" HasDialogLauncher="True" Command="{StaticResource ClipboardGroupCommand}">

                    <r:RibbonButton Name="Copy" Command="{StaticResource CopyCommand}"></r:RibbonButton>

                </r:RibbonGroup>

                <r:RibbonGroup Name="Fonts">

                    <r:RibbonButton  Name="Paste"></r:RibbonButton>

                </r:RibbonGroup>

            </r:RibbonTab>

            <r:RibbonTab Label="Insert">

            </r:RibbonTab>

            <r:RibbonTab Label="Help">

            </r:RibbonTab>

        </r:Ribbon>

    </Grid>

</r:RibbonWindow>

 

Share on Facebook

To end the inactive blogging period, I have decided to start a new series of posts on my blog. Each one of these posts would describe something new I learnt during the day. I have chosen to name it “What I Learnt Today?”

Shortly, I would post a tutorial on creating Ribbon Control using Windows Presentation Foundation.

Share on Facebook