---

eclipselauncher.c

Go to the documentation of this file.

/*
 * Copyright (c) 2002 Ingo Richter and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *    Ingo Richter - Initial implementation.
 */
#define strict

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <string.h>
#include "resource.h"

#include <assert.h>

#include "persistent.h"
#include "eclipselauncher.h"
#include "launcherconfig.h"
#include "clipboard.h"
#include "changeConfigurationDialog.h"
#include "utils.h"

/* prototype for the dialog box function. */
LRESULT MainDialogWindowProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam);

/* Event Handler */
BOOL OnInitializeApp(HWND hDlg, HWND wParam, LPARAM lParam);
BOOL OnExitApp(HWND hDlg);
BOOL OnCommandHelper(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify);
void OnDeleteConfiguration(HWND hwnd);
int OnAddNewConfiguration(HWND hwnd);
int OnEditNewConfiguration(HWND hwnd);
void OnLeftButtonDoubleClick(HWND hwnd, BOOL what, int x, int y, UINT keyFlags);
void OnSize(HWND hDialog, int type, int notused1, int notused2);

//extern BOOL gConfigChanged = FALSE;
static WNDPROC gOldListViewWindowProc;
static HWND ghMainDialog;
static BOOL gSendToTray = FALSE;

// Tray Data
static NOTIFYICONDATA gNotifyIconData;
static HMENU ghTrayMenu;

#define HEADER_CONFIGURATION_NAME   "Configuration Name"
#define HEADER_WORKSPACE_PATH       "Workspace Directory"
#define HEADER_VMPARAMETER          "VM Parameter"
#define HEADER_JAVAVM               "Java VM"

TCHAR* headerLabel[] = { HEADER_CONFIGURATION_NAME, HEADER_WORKSPACE_PATH, HEADER_JAVAVM, HEADER_VMPARAMETER };
int headerLabelSize[] = { 150, 150, 150, 150 };

int APIENTRY WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR lpCmdLine, int nCmdShow)
{
    TCHAR appName[APPNAME_BUFFER_SIZE] = {0};
    HWND hDialog;
    MSG msg;
    WNDCLASS wc;

    memset(&wc, 0, sizeof(wc));
    wc.lpfnWndProc = DefDlgProc;
    wc.cbWndExtra = DLGWINDOWEXTRA;
    wc.hInstance = hinst;
    wc.hIcon = LoadIcon(NULL, MAKEINTRESOURCE(IDI_ECLIPSELAUNCHER));
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
    wc.lpszClassName = LocString(IDS_APPNAME, appName);
    RegisterClass(&wc);

    hDialog = CreateDialog(hinst, MAKEINTRESOURCE(IDD_MAINDIALOG_NOBUTTONS), NULL, (DLGPROC) MainDialogWindowProc);
    ListView_SetExtendedListViewStyleEx(GetDlgItem(hDialog, ID_CONFIGLIST), LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP /*| LVS_EX_GRIDLINES*/, LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP /*| LVS_EX_GRIDLINES*/);
    if(!hDialog)
    {
        TCHAR buf[BUFFERSIZE_256];
        wsprintf(buf, "Error %ld", GetLastError());
        MessageBox(0, buf, "CreateDialog", MB_ICONEXCLAMATION | MB_OK);
        return 1;
    }

    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!IsDialogMessage(hDialog, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return msg.wParam;

/*  return DialogBox(hinst, MAKEINTRESOURCE(IDD_MAINDIALOG_NOBUTTONS), NULL, (DLGPROC) MainDialogWindowProc); */
}

/*
 * Describe here
 * @param lpSubkey
 * @param lpClass
 * @param lpData
 */
LPLAUNCHERCONFIG hitTestForLauncherConfig(HWND hwnd, int x, int y)
{
    LPLAUNCHERCONFIG launcherConfig = NULL;
    int listEntryPosition;

    LV_HITTESTINFO hitTest = {0};
    hitTest.pt.x = x;
    hitTest.pt.y = y;
    hitTest.flags = LVHT_ONITEM;

    listEntryPosition = ListView_HitTest(hwnd, &hitTest);

    if(listEntryPosition != (-1))
    {
        // select the Entry before determinig the active configuration
        ListView_SetItemState(hwnd, listEntryPosition, LVIS_SELECTED | LVIS_FOCUSED, 0xffff);
        launcherConfig = getLauncherConfig(hwnd, listEntryPosition);
    }

    return(launcherConfig);
}

/*
 * Describe here
 * @param lpSubkey
 * @param lpClass
 * @param lpData
 */
void showPopupMenu(HMENU hMenu, HWND hMainWindow)
{
    POINT cursorPos;
    GetCursorPos(&cursorPos);

    // PRB: Menus for Notification Icons Don't Work Correctly
    SetForegroundWindow(hMainWindow);
    TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, cursorPos.x, cursorPos.y, 0, hMainWindow, NULL);
    PostMessage(hMainWindow, WM_NULL, 0, 0);
}

//int OnRightButtonDown(HWND hwnd, int x, int y, UINT flags)
/*
 * Describe here
 * @param lpSubkey
 * @param lpClass
 * @param lpData
 */
int OnRightButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
    POINT cursorPos;
    HMENU hContextMenu;
    TCHAR* locbuffer = (TCHAR*) malloc(256);

    LPLAUNCHERCONFIG launcherConfig = hitTestForLauncherConfig(hwnd, x, y);

    hContextMenu = CreatePopupMenu();

    if(launcherConfig != NULL)
    {
        TCHAR buffer[BUFFERSIZE_256] = {0};

        wsprintf(buffer, LocString(IDS_POPUP_EDIT_CONFIGURATION, locbuffer), getName(launcherConfig));
        AppendMenu(hContextMenu, MF_STRING, (UINT) IDM_EDITCONFIGURATION, 
            buffer); 

        wsprintf(buffer, LocString(IDS_POPUP_DUPLICATE_CONFIGURATION, locbuffer), getName(launcherConfig));
        AppendMenu(hContextMenu, MF_STRING, (UINT) IDM_DUPLICATECONFIGURATION, 
            buffer); 

        AppendMenu(hContextMenu, MF_MENUBREAK, (UINT) 0, 
            NULL); 

        wsprintf(buffer, LocString(IDS_POPUP_DELETE_CONFIGURATION, locbuffer), getName(launcherConfig));
        AppendMenu(hContextMenu, MF_STRING, (UINT) IDM_DELETECONFIGURATION, 
            buffer);
    }
    else
    {
        AppendMenu(hContextMenu, MF_STRING, (UINT) IDM_ADDCONFIGURATION, 
            LocString(IDS_POPUP_ADD_NEW_CONFIGURATION, locbuffer)); 
    }

    GetCursorPos(&cursorPos);
    TrackPopupMenu(hContextMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, cursorPos.x, cursorPos.y, 0, ghMainDialog, NULL);

    free(locbuffer);

    return(1);
}

/*
 * Locate an Environment Variable, expand them and create a new String with the Value of the
 * expanded Variable.
 * Supports only "ONE" Environment Variable at the Moment!!!
 * First Version! Needs to be improved!
 */
TCHAR* expandEnvironmentVariable(TCHAR* stringToExpand, TCHAR* newBuffer, int bufferSize)
{
    TCHAR* startEnvironmentVariable = NULL;
    assert(stringToExpand != NULL);

    startEnvironmentVariable = strchr(stringToExpand, '%');
    if (startEnvironmentVariable != NULL)
    {
        int startIndex = startEnvironmentVariable - stringToExpand + 1;

        TCHAR* endEnvironmentVariable = strrchr(stringToExpand, '%');
        if (endEnvironmentVariable != NULL)
        {
            int endIndex = endEnvironmentVariable - stringToExpand + 1;

            TCHAR environmentVariableName[BUFFERSIZE_512] = {0};
            TCHAR environmentVariableValue[BUFFERSIZE_512] = {0};

            strncpy(environmentVariableName, stringToExpand + startIndex, endIndex - startIndex - 1);
            GetEnvironmentVariable(environmentVariableName, environmentVariableValue, 512);

            lstrcpyn(newBuffer, stringToExpand, startIndex);
            strcat(newBuffer, environmentVariableValue);
            strcat(newBuffer, stringToExpand + endIndex);
        }
    }
    else /* nothing found */
    {
        lstrcpyn(newBuffer, stringToExpand, bufferSize);
    }

    return newBuffer;
}

/*
 * Describe here
 * @param lpSubkey
 * @param lpClass
 * @param lpData
 */
void executeLaunchConfiguration(LPLAUNCHERCONFIG launcherConfiguration)
{
    int CMDLineLength = 4096;
    TCHAR* commandline = (TCHAR*)malloc(CMDLineLength);
    ZeroMemory(commandline, CMDLineLength);

    assert(launcherConfiguration != NULL);

    if(lstrlen(getWorkspacePath(launcherConfiguration)) > 0)
    {
        TCHAR tempBuffer[BUFFERSIZE_512] = {0};
        wsprintf(commandline, "%s %s %s %s", expandEnvironmentVariable(getExecutablePath(launcherConfiguration), tempBuffer, 512), 
                                            "-showlocation -data", 
                                            getWorkspacePath(launcherConfiguration),
                                            getOptionalParameter(launcherConfiguration));
    }
    else
    {
        TCHAR tempBuffer[BUFFERSIZE_512] = {0};
        wsprintf(commandline, "%s %s %s", expandEnvironmentVariable(getExecutablePath(launcherConfiguration), tempBuffer, 512),
                                        "-showlocation",
                                        getOptionalParameter(launcherConfiguration));
    }

    if(lstrlen(getJavaVM(launcherConfiguration)) > 0)
    {
        TCHAR tempBuffer[BUFFERSIZE_512 * 2] = {0};
        wsprintf(tempBuffer, " -vm %s", getJavaVM(launcherConfiguration));
        lstrcat(commandline, tempBuffer);
    }

    if(lstrlen(getVMParameter(launcherConfiguration)) > 0)
    {
        TCHAR tempBuffer[BUFFERSIZE_512 * 2] = {0};
        wsprintf(tempBuffer, " -vmargs %s", getVMParameter(launcherConfiguration));
        lstrcat(commandline, tempBuffer);
    }

    ShowWindow(ghMainDialog, SW_HIDE);

    // >31 means success!
    if(WinExec(commandline, SW_SHOW) > 31)
    {
//      launcherConfiguration->isCurrentlyRunning = TRUE;
    }
    else
    {
        TCHAR messageBuffer[BUFFERSIZE_512] = {0};
        TCHAR locString[BUFFERSIZE_256] = {0};
        wsprintf(messageBuffer, "%s\n%s", LocString(IDS_ERROR_EXECUTING_CONFIGURATION, locString), commandline);
        MessageBox(ghMainDialog, messageBuffer, "Error during Execution", MB_ICONEXCLAMATION | MB_OK);
    }

    free(commandline);
}

/*
 * Describe here
 * @param lpSubkey
 * @param lpClass
 * @param lpData
 */
void OnLeftButtonDoubleClick(HWND hwnd, BOOL what, int x, int y, UINT keyFlags)
{
    LPLAUNCHERCONFIG launcherConfig = hitTestForLauncherConfig(hwnd, x, y);

    if(launcherConfig != NULL)
    {
        /* if the Control Key is pressed open to edit. */
        if((keyFlags & MK_CONTROL) == MK_CONTROL)
        {
            OnEditNewConfiguration(ghMainDialog);
        }
        else
        {
            executeLaunchConfiguration(launcherConfig);
        }
    }
}

void OnKeyPressed(HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags)
{
    switch(vk)
    {
        case VK_DELETE:
        {
            OnDeleteConfiguration(hwnd);
        }
        break;

        case VK_INSERT:
        {
            OnAddNewConfiguration(ghMainDialog);
        }
        break;
    }
}

LRESULT ListViewWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, OnLeftButtonDoubleClick);
        HANDLE_MSG(hwnd, WM_RBUTTONDOWN, OnRightButtonDown);
        HANDLE_MSG(hwnd, WM_KEYUP, OnKeyPressed);
    }

    return(CallWindowProc(gOldListViewWindowProc, hwnd, msg, wParam, lParam));
}

void setUpTrayIcon(HWND hDialog)
{
    TCHAR buffer[BUFFERSIZE_256] = {0};

    ghTrayMenu = LoadMenu(getApplicationInstance(), MAKEINTRESOURCE(ID_TRAYMENU));
    
    gNotifyIconData.cbSize = sizeof(NOTIFYICONDATA);
    gNotifyIconData.hWnd = hDialog;
    gNotifyIconData.uID = 0;
    gNotifyIconData.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
    gNotifyIconData.uCallbackMessage = WM_USER;
    gNotifyIconData.hIcon = LoadImage(getApplicationInstance(), MAKEINTRESOURCE(IDI_ECLIPSELAUNCHER), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
    lstrcpy(gNotifyIconData.szTip, LocString(IDS_POPUP_ENABLE_HINT, buffer));

    Shell_NotifyIcon(NIM_ADD, &gNotifyIconData);
}

void setUpListViewHeader(HWND hDialog)
{
    HWND hListBox;
    int headerCount;
    int headers = sizeof(headerLabel) / sizeof(headerLabel[0]);
    
    LV_COLUMN column = {0};

    column.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
    column.cx = 150;
    column.fmt = LVCFMT_LEFT;

    hListBox = GetDlgItem(hDialog, ID_CONFIGLIST);

    for(headerCount = 0; headerCount < headers; headerCount++)
    {
        column.pszText = headerLabel[headerCount];
        column.cx = headerLabelSize[headerCount];
        ListView_InsertColumn(hListBox, headerCount, &column);
    }
  }

/*
You should add your initialization code here. This function will be called
when the dialog box receives the WM_INITDIALOG message.
*/
BOOL OnInitializeApp(HWND hDlg, HWND wParam, LPARAM lParam)
{
    TCHAR appNameVersion[BUFFERSIZE_256] = {0};
    TCHAR appName[APPNAME_BUFFER_SIZE] = {0};
    TCHAR appVersion[APPVERSION_BUFFER_SIZE] = {0};

    HWND hListBox = GetDlgItem(hDlg, ID_CONFIGLIST);

    wsprintf(appNameVersion, "%s %s", LocString(IDS_APPNAME, appName), LocString(IDS_APPVERSION, appVersion));

    setUpListViewHeader(hDlg);
    
    loadConfiguration(hListBox);

/*  EnableWindow(GetDlgItem(hDlg, ID_EDITCONFIGURATION), FALSE);
    EnableWindow(GetDlgItem(hDlg, ID_DELETECONFIG), FALSE);
*/
    gOldListViewWindowProc = (WNDPROC)GetWindowLong(hListBox, GWL_WNDPROC);
    SetWindowLong(hListBox, GWL_WNDPROC, (LONG)ListViewWindowProc);

    SetWindowText(hDlg, appNameVersion);

    setUpTrayIcon(hDlg);

    ShowWindow(hDlg, SW_HIDE);

    return TRUE;
}

BOOL OnExitApp(HWND hDlg)
{
    // Remove from tray
    Shell_NotifyIcon(NIM_DELETE, &gNotifyIconData);

    disposeAllConfigurations(GetDlgItem(hDlg, ID_CONFIGLIST));

    DestroyMenu(ghTrayMenu);

    EndDialog(hDlg,0);
    return TRUE;
}

/*
 * Delete the Configuration that is currently selected in hListBox.
 */
void OnDeleteConfiguration(HWND hListBox)
{
    int currentSelection = getCurrentSelection(hListBox);
    if(currentSelection != LB_ERR)
    {
        LPLAUNCHERCONFIG data = getLauncherConfig(hListBox, currentSelection);
        int result;
        TCHAR resString[STRINGBUFFER_SIZE];// = (TCHAR*)malloc(bufferSize);
        TCHAR message[STRINGBUFFER_SIZE];
        TCHAR dialogTitle[STRINGBUFFER_SIZE];

        wsprintf(message, LocString(IDS_REMOVE_CONFIGURATION, resString), getName(data));

        LocString(IDS_REMOVE_CONFIGURATION_TITLE, resString);
        wsprintf(dialogTitle, resString);

        result = MessageBox(NULL, message, dialogTitle, MB_YESNO);
        if(IDYES == result)
        {
            releaseLauncherConfig(data);
            ListView_DeleteItem(hListBox, currentSelection);
            saveConfiguration(hListBox);
        }
    }
}

void restoreWindow(HWND hWindow)
{
    ShowWindow(hWindow, SW_SHOWNORMAL);
    SetForegroundWindow(hWindow);
}


BOOL OnCommandHelper(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
    // we ignore all other Messages
    if (codeNotify == 0)
    {
        switch (id)
        {
            case IDCANCEL:
            {
                EndDialog(hwnd, 0);
                return 1;
            }
            break;

            case ID_TRAYEXIT:
            {
                gSendToTray = FALSE;
                EndDialog(hwnd,0);
                SendMessage(hwnd, WM_DESTROY, 0, 0);
                return TRUE;
            }

            case IDM_ADDCONFIGURATION:
            case ID_ADDCONFIGURATION:
            {
                return(OnAddNewConfiguration(hwnd));
            }

            case IDM_EDITCONFIGURATION:
            case ID_EDITCONFIGURATION:
            {
                return(OnEditNewConfiguration(hwnd));
            }

            case IDM_DUPLICATECONFIGURATION:
            {
                HWND hListbox = GetDlgItem(hwnd, ID_CONFIGLIST);
                OnDuplicateLaunchConfiguration(hListbox);
            }
            break;

            case IDM_DELETECONFIGURATION:
            case ID_DELETECONFIG:
            {
                HWND hListBox = GetDlgItem(hwnd, ID_CONFIGLIST);
                OnDeleteConfiguration(hListBox);
                return TRUE;
            }

            case ID_RESTOREFROMTRAY:
            {
                restoreWindow(hwnd);
            }
            break;

            case ID_ABOUT:
            {
                TCHAR appAbout[BUFFERSIZE_512] = {0};
                TCHAR appVersionString[BUFFERSIZE_512 * 2] = {0};
                TCHAR appName[APPNAME_BUFFER_SIZE] = {0};
                TCHAR appVersion[APPVERSION_BUFFER_SIZE] = {0};

                LocString(APP_ABOUT, appAbout);
                LocString(IDS_APPNAME, appName);
                LocString(IDS_APPVERSION, appVersion);
                
                wsprintf(appVersionString, "%s %s\n%s", appName, appVersion, appAbout);
                MessageBox(hwnd, appVersionString, "About EclipseLauncher", MB_OK | MB_ICONEXCLAMATION);
            }
            break;

            // this is to capture the Execute from the Tray popup Menu
            default:
            {
                int launcherConfigNum = id - IDM_EXECUTECONFIGURATION;
                LPLAUNCHERCONFIG launcherConfig = getLauncherConfig(GetDlgItem(hwnd, ID_CONFIGLIST), launcherConfigNum);
                executeLaunchConfiguration(launcherConfig);
            }
        }
    }

    return TRUE;
}

void OnSize(HWND hDialog, int type, int notused1, int notused2)
{
    if(type == SIZE_MINIMIZED)
    {
        ShowWindow(hDialog, SW_HIDE);
    }
}

BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
    lpCreateStruct->style &= WS_MINIMIZE;

    return 0;
}

void OnSysCommand(HWND hDialog, UINT cmd, int x, int y)
{
    if(cmd == SC_MINIMIZE || cmd == SC_CLOSE)
    {
        ShowWindow(hDialog, SW_HIDE);
        gSendToTray = TRUE;
    }
}

LRESULT MainDialogWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND editLabelControl;
    ghMainDialog = hwnd;

    switch (msg)
    {
        HANDLE_MSG(hwnd, WM_CREATE, OnCreate);
        HANDLE_MSG(hwnd, WM_INITDIALOG, OnInitializeApp);
        HANDLE_MSG(hwnd, WM_COMMAND, OnCommandHelper);
        HANDLE_MSG(hwnd, WM_SYSCOMMAND, OnSysCommand);
        HANDLE_MSG(hwnd, WM_SIZE, OnSize);

        case WM_NOTIFY:
        {
            int idCtrl = (int) wParam; 
            LPNMHDR pnmh = (LPNMHDR) lParam;
            
            switch(pnmh->code)
            {
                case LVN_BEGINLABELEDIT:
                {
                    editLabelControl = ListView_GetEditControl(pnmh->hwndFrom);
                    return FALSE; /* allow editiing */
                }
                break;

                case LVN_ENDLABELEDIT:
                {
                    char text[255]="";
                    HWND hListView = pnmh->hwndFrom;
                    int iIndex = SendMessage(hListView, LVM_GETNEXTITEM, -1, LVNI_FOCUSED); // get selected item
                    LPLAUNCHERCONFIG data = getLauncherConfig(hListView, iIndex);
 
                    GetWindowText(editLabelControl, text, sizeof(text)); // get the text into a buffer              
                    setName(data, text, sizeof(text));
                    updateLauchnerConfig(hListView, data, iIndex);
                    saveConfiguration(hListView);
                }
                break;

                case LVN_GETINFOTIP:
                {
                    TCHAR* tempValue;
                    TCHAR buffer[BUFFERSIZE_512*2] = {0};
                    LPNMLVGETINFOTIP pGetInfoTip = (LPNMLVGETINFOTIP)lParam;
                    LPLAUNCHERCONFIG data = getLauncherConfig(pGetInfoTip->hdr.hwndFrom, pGetInfoTip->iItem);
                    
                    wsprintf(buffer, "Name:\t\t%s\nExecutable:\t%s", getName(data), getExecutablePath(data));
                    
                    tempValue = getJavaVM(data);

                    if (lstrlen(tempValue))
                    {
                        lstrcat(buffer, "\nJavaVM:\t");
                        lstrcat(buffer, tempValue);
                    }

                    tempValue = getWorkspacePath(data);
                    if (lstrlen(tempValue))
                    {
                        lstrcat(buffer, "\nWorkspace:\t");
                        lstrcat(buffer, tempValue);
                    }

                    tempValue = getOptionalParameter(data);
                    if (lstrlen(tempValue))
                    {
                        lstrcat(buffer, "\nParameter:\t");
                        lstrcat(buffer, tempValue);
                    }

                    tempValue = getVMParameter(data);
                    if (lstrlen(tempValue))
                    {
                        lstrcat(buffer, "\nVM Parameter:\t");
                        lstrcat(buffer, tempValue);
                    }

                    lstrcpy(pGetInfoTip->pszText, buffer);
                }
            }
        }
        break;

        case WM_DESTROY:
        {
            if( gSendToTray != TRUE)
            {
                OnExitApp(hwnd);
                PostQuitMessage(0);
            }
        }
        break;
/*
        case WM_MEASUREITEM:
        {
            SIZE size = {0};

            // Retrieve a device context for the main window.  
            HDC hdc = GetDC(hwnd); 
 
            // Retrieve pointers to the menu item's 
            // MEASUREITEMSTRUCT structure and MYITEM structure. 
 
            LPMEASUREITEMSTRUCT lpmis = (LPMEASUREITEMSTRUCT) lParam; 
            LPLAUNCHERCONFIG launcherConfig = (LPLAUNCHERCONFIG) lpmis->itemData; 
 
            // check if we are already running
            if(launcherConfig->isCurrentlyRunning != FALSE)
            {
                launcherConfig->isCurrentlyRunning = lockfileIsDeleteable(launcherConfig->workspacePath);
            }

            // Retrieve the width and height of the item's string, 
            // and then copy the width and height into the 
            // MEASUREITEMSTRUCT structure's itemWidth and 
            // itemHeight members. 
 
            GetTextExtentPoint32(hdc, launcherConfig->name, lstrlen(launcherConfig->name), &size); 
            lpmis->itemWidth = size.cx; 
            lpmis->itemHeight = size.cy; 
 
            ReleaseDC(hwnd, hdc); 
 
            return TRUE; 
        }
        break;
        
        case WM_DRAWITEM: 
        {
            COLORREF crText;
            COLORREF crBkgnd;

            int wCheckX;
            int nTextX;
            int nTextY;
            BOOL fSelected = FALSE;

            // Get pointers to the menu item's DRAWITEMSTRUCT 
            // structure and MYITEM structure. 
 
            LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) lParam; 
            LPLAUNCHERCONFIG launcherConfig = (LPLAUNCHERCONFIG) lpdis->itemData; 
 
            // If the user has selected the item, use the selected 
            // text and background colors to display the item. 
 
            if (lpdis->itemState & ODS_SELECTED)
            { 
                crBkgnd = SetBkColor(lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT)); 
                fSelected = TRUE;
            } 
 
            if (launcherConfig->isCurrentlyRunning)
            {
                crText = SetTextColor(lpdis->hDC, RGB(0xff,0x0,0x0)); 
            }
            
            // Remember to leave space in the menu item for the 
            // check-mark bitmap. Retrieve the width of the bitmap 
            // and add it to the width of the menu item. 
 
            wCheckX = GetSystemMetrics(SM_CXMENUCHECK); 
            nTextX = wCheckX + lpdis->rcItem.left; 
            nTextY = lpdis->rcItem.top; 
 
            // Select the font associated with the item into the 
            // item's device context, and then draw the string. 
 
//            hfontOld = SelectObject(lpdis->hDC, pmyitem->hfont); 
            ExtTextOut(lpdis->hDC, nTextX, nTextY, ETO_OPAQUE, 
                &lpdis->rcItem, launcherConfig->name, 
                lstrlen(launcherConfig->name), NULL); 
 
            // Select the previous font back into the device 
            // context. 
 
//            SelectObject(lpdis->hDC, hfontOld); 
 
            // Return the text and background colors to their 
            // normal state (not selected). 
 
            if (fSelected) 
            { 
//                SetTextColor(lpdis->hDC, crText); 
                SetBkColor(lpdis->hDC, crBkgnd); 
            } 
 
            return TRUE; 
        }
        break;
*/
        case WM_USER:
        {
            switch(lParam)
            {
                // @TODO: Make this configurable for the user. Allow the User to enable the Popup on Right or left clicks.
                case WM_RBUTTONUP:
                {
                    HWND hConfigList = GetDlgItem(hwnd, ID_CONFIGLIST);
                    int configurationCount = getConfigurationCount(hConfigList); 
                    HMENU hSubMenu = GetSubMenu(ghTrayMenu, 0);
                    LPLAUNCHERCONFIG launcherConfig;

                    int configurationNum;
                    int menuItemCount = GetMenuItemCount(hSubMenu);
                    int itemCount;
                    int flags;
                    MENUITEMINFO menuiteminfo = {0};
                    menuiteminfo.cbSize = sizeof(MENUITEMINFO);
                    menuiteminfo.fMask = MIIM_ID;

                    for(itemCount = 0; itemCount < menuItemCount; itemCount++)
                    {
                        // always get the 0th Element!
                        GetMenuItemInfo(hSubMenu, 0, TRUE, &menuiteminfo);

                        if(menuiteminfo.wID == (UINT)(IDM_EXECUTECONFIGURATION + itemCount))
                        {
                            DeleteMenu(hSubMenu, 0, MF_BYPOSITION);
                        }

                        if(menuiteminfo.wID == 9999)
                        {
                            DeleteMenu(hSubMenu, 0, MF_BYPOSITION);
                            break; // Now our Delimiter has marked the end...
                        }
                    }
                    
                    for(configurationNum = 0; configurationNum < configurationCount; configurationNum++)
                    {
                        launcherConfig = getLauncherConfig(hConfigList, configurationNum);
                        
/*                      InsertMenu(hSubMenu, configurationNum, MF_BYPOSITION | MF_OWNERDRAW, (UINT) IDM_EXECUTECONFIGURATION + configurationNum, 
                            launcherConfig); 
*/
                        flags = MF_BYPOSITION;

                        if(! lockfileIsDeleteable(getWorkspacePath(launcherConfig)))
                        {
                            flags |= MF_CHECKED;
                        }

                        InsertMenu(hSubMenu, configurationNum, flags, (UINT) IDM_EXECUTECONFIGURATION + configurationNum, 
                            getName(launcherConfig));
                    }

                    InsertMenu(hSubMenu, configurationNum, MF_BYPOSITION, 9999, NULL); 

                    showPopupMenu(hSubMenu, hwnd);

                    return TRUE;
                }
                break;

                case WM_LBUTTONDBLCLK:
                {
                    restoreWindow(hwnd);
                    return TRUE;
                }
                break;
            }
        }
        break;
    }

    return FALSE;
}

int OnAddNewConfiguration(HWND hwnd)
{
    return(DialogBoxParam(getApplicationInstance(),
                            MAKEINTRESOURCE(IDD_ADDCONFIGDLG),
                            hwnd,
                            (DLGPROC) HandleAddConfigurationDialogProc,
                            MAKELPARAM(NULL, GetDlgItem(hwnd, ID_CONFIGLIST))));
}

int OnEditNewConfiguration(HWND hwnd)
{
    return(DialogBoxParam(getApplicationInstance(),
                            MAKEINTRESOURCE(IDD_ADDCONFIGDLG),
                            hwnd,
                            (DLGPROC) HandleEditConfigurationDialogProc,
                            MAKELPARAM(NULL, GetDlgItem(hwnd, ID_CONFIGLIST))));
}

/*
BOOL CTestbed2Dlg::OnCommand(WPARAM wParam, LPARAM lParam) 
{
   CString csURL;

   if (HIWORD(wParam) == STN_CLICKED)
   {
      if (LOWORD(wParam) == IDC_URL)
      {
         FromHandle ((HWND)lParam)->GetWindowText (csURL);
         ShellExecute (GetSafeHwnd(),
                       "open",
                       csURL,
                       NULL,
                       NULL,
                       SW_SHOWNORMAL);
         return TRUE;
      }
   }
   return (CDialog::OnCommand(wParam,lParam));
}
*/

---