C / C++ / MFC

yu-jian wrote:

Is anyone know how to design a good one as visual studio that cat drag and drop controls?

jaafar tribak wrote:

First of all, I would like to apologize for posting this question in the C++ forum as it deals with Classic VB (VBA) ... The reason I posted here is because I can't get an answer (not even a hint) in the VB/VBA foums ... I searched the web extensively but without any luck

Member 8833981 wrote:

I try to set the label with a transparent background.

timeLabel->Background = gcnew System::Windows::Media::SolidColorBrushSystem::Windows::Media::Colors::Transparent);

mbatra31 wrote:

I want to download file from a given URL. I am using URLDownloadToFile() function...

Member 9350237 wrote:

I'm hoping to use a finite state machine(FSM) to switch between screens...

Quote:

but every article iv read about them is different and sometimes they leave out details, I couldn't understand it properly.

struct FSMData
{
  FSMState state;
  // other useful data
};
 
void update_fsm(FSMData & fsmd)
{
  switch(fsmd.state)
  {
  case STATE_MENU:
   handle_menu(fsmd);
   break;
  case STATE_GAME:
   handle_game(fsmd);
  //...
  }
 
void handle_menu(FSMData & fsmd)
{
  //...
  if ( userSelection() == PLAY_GAME)
  {
    // cleanup here
    fsmd.state = STATE_GAME;
    return;
  } 
  // ...
}
 
void handle_game(FSMData & fsmd)
{
  // ...
  if (userInput() == QUIT_GAME)
  {
    // cleanup here
    fsmd.state = STATE_MENU;
    return;
  }
  // ...
}

ForNow wrote:

So if Unicode is character representation by 2 bytes. what is multi byte ?

int minValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return -1;
    else {
        while (current->left != NULL)
            current = current->left;
        return current->num;
    }
}
 
int maxValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL)
        return -1;
    else
     {
        while (current->right != NULL)
            current = current->right;
        return current->num;
     }
}

int min = minValue(root)
int max = maxValue(root));
printf("Min Val: %d Max Val: %d\n", min, max);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct treenode {
    int num;
    struct treenode * left;
    struct treenode * right;
} TreeNode;
 
int recLookup (TreeNode *, int);
int lookUp(TreeNode *, int);
int sizeRec(TreeNode *);
int maxDepth(TreeNode *);
int minValue(TreeNode *);
int maxValue(TreeNode *);
int hasPathSum(TreeNode *, int);
 
TreeNode * createNode (int);
TreeNode * insertRec(TreeNode *, int);
TreeNode * buildTree();
 
void deleteRec(TreeNode *);
void printIncreasing(TreeNode *);
void printPostOrder(TreeNode *);
void printPaths(TreeNode *);
void printPathRecur(TreeNode *, int[], int);
 
enum { FALSE, TRUE };
 

int main (void) {
    TreeNode * root = buildTree();
    printf("Size: %d\n", sizeRec(root));
    printf("Max Depth: %d\n", maxDepth(root));
    printf("Min Value: %d\n", minValue(root));
    printf("Max Value: %d\n", maxValue(root));
    printIncreasing(root); puts("");
    printPostOrder(root); puts("");
    printf("Has path sum 15: %d\n", hasPathSum(root, 15));
    printPaths(root);
    // not sure why line below throws segmentation core
    printf("Min Val: %d Max Val: %d\n", minValue(root), maxValue(root));
 
    deleteRec(root);
 

    return 0;
}
 
void printPaths(TreeNode * root) {
    int path[10];
    int pathLen = 0;
    printPathRecur(root, path, pathLen);
}
 
void printPathRecur(TreeNode * node, int path[], int pathLen) {
    if (node == NULL) return;
    path[pathLen] = node->num;
    pathLen++;
    if (node->right == NULL && node->left == NULL) {
        int i;
        for (i = 0; i < pathLen; i++)
            printf("%d ", path[i]);
        puts("");
    }
    else {
        printPathRecur(node->left, path, pathLen);
        printPathRecur(node->right, path, pathLen);
    }
}
 
int hasPathSum(TreeNode * root, int num) {
    TreeNode * current = root;
    if (current == NULL)
        return num == 0;
    else {
        int n = num - current->num;
        return
            hasPathSum(current->left, n) ||
            hasPathSum(current->right, n);
    }
}
 

void printPostOrder(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return;
    printPostOrder(current->left);
    printPostOrder(current->right);
    printf("%d ", current->num);
}
 
void printIncreasing(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return;
    printIncreasing(current->left);
    printf("%d ", current->num);
    printIncreasing(current->right);
}
 
int minValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return -1;
    else {
        while (current->left != NULL)
            current = current->left;
        return current->num;
    }
}
 
int maxValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL)
        return -1;
    else
     {
        while (current->right != NULL)
            current = current->right;
        return current->num;
     }
}
 
int maxDepth (TreeNode * root) {
    if (root == NULL) return 0;
    else {
        int lDepth = maxDepth(root->left);
        int rDepth = maxDepth(root->right);
        if (lDepth > rDepth) return (lDepth + 1);
        else return (rDepth + 1);
    }
}
 
void deleteRec(TreeNode * root) {
    if (root == NULL) return;
    else {
        deleteRec(root->right);
        deleteRec(root->left);
        free(root);
    }
}
 
int sizeRec (TreeNode * root) {
    if (root == NULL) return 0;
    else
        return 1 + sizeRec(root->right) + sizeRec(root->left);
}
 
TreeNode * buildTree() {
    TreeNode * root = insertRec(root, 4);
    root = insertRec(root, 3);
    root = insertRec(root, 6);
    return root;
}
 
TreeNode * insertRec (TreeNode * node, int num) {
    if (node == NULL)
        return createNode(num);
    else {
        if (num <= node->num) node->left = insertRec(node->left, num);
        else node->right = insertRec(node->right, num);
    }
    return node;
}
 
TreeNode * createNode(int num) {
    TreeNode * newNode = (TreeNode *) malloc (sizeof (TreeNode));
    newNode->num = num;
    newNode->right = NULL;
    newNode->left = NULL;
    return newNode;
}
 
int lookUp(TreeNode * node, int num) {
    while (node != NULL) {
        if (node->num == num) return TRUE;
        else {
            if (num < node->num) node = node->left;
            else node = node->right;
        }
    }
    return FALSE;
}
 

int recLookup (TreeNode * node, int num) {
    if (node == NULL)
        return FALSE;
    else {
        if (node->num == num) return TRUE;
        else {
            if (num < node->num) return recLookup(node->left, num);
            else return recLookup(node->right, num);
        }
    }
}

TreeNode * root = insertRec(NULL, 4);