Win_ent.cpp

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
#include "stdafx.h"
#include "qe3.h"
#include "entityw.h"
#include "TexWnd.h"
#include "WaveOpen.h"

int rgIds[EntLast] = {
    IDC_E_LIST,
    IDC_E_COMMENT,
    IDC_CHECK1,
    IDC_CHECK2,
    IDC_CHECK3,
    IDC_CHECK4,
    IDC_CHECK5,
    IDC_CHECK6,
    IDC_CHECK7,
    IDC_CHECK8,
    IDC_CHECK9,
    IDC_CHECK10,
    IDC_CHECK11,
    IDC_CHECK12,
    IDC_E_PROPS,
    IDC_E_0,
    IDC_E_45,
    IDC_E_90,
    IDC_E_135,
    IDC_E_180,
    IDC_E_225,
    IDC_E_270,
    IDC_E_315,
    IDC_E_UP,
    IDC_E_DOWN,
    IDC_E_DELPROP,

    IDC_STATIC_KEY,
    IDC_E_KEY_FIELD,
    IDC_STATIC_VALUE,
    IDC_E_VALUE_FIELD,

    IDC_E_COLOR,

  IDC_BTN_ASSIGNSOUND, 
  IDC_BTN_ASSIGNMODEL

};

HWND hwndEnt[EntLast];
CTabCtrl g_wndTabs;

int     inspector_mode;     // W_TEXTURE, W_ENTITY, or W_CONSOLE

qboolean    multiple_entities;

entity_t    *edit_entity;


BOOL CALLBACK EntityWndProc(
    HWND hwndDlg,   // handle to dialog box
    UINT uMsg,      // message
    WPARAM wParam,  // first message parameter
    LPARAM lParam); // second message parameter

void SizeEntityDlg(int iWidth, int iHeight);
void AddProp();
void GetTexMods(void);


LRESULT (CALLBACK* OldFieldWindowProc) (HWND, UINT, WPARAM, LPARAM);
LRESULT (CALLBACK* OldEntityListWindowProc) (HWND, UINT, WPARAM, LPARAM);

/*
=========================
FieldWndProc

Just to handle tab and enter...
=========================
*/
BOOL CALLBACK FieldWndProc(
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_CHAR:
        if (LOWORD(wParam) == VK_TAB)
            return FALSE;
        if (LOWORD(wParam) == VK_RETURN)
            return FALSE;
        if (LOWORD(wParam) == VK_ESCAPE)
        {
            SetFocus (g_qeglobals.d_hwndCamera);
            return FALSE;
        }
        break;

    case WM_KEYDOWN:
        if (LOWORD(wParam) == VK_TAB)
        {
            if (hwnd == hwndEnt[EntKeyField])
            {
                SendMessage (hwndEnt[EntValueField], WM_SETTEXT, 0, (long)"");
                SetFocus (hwndEnt[EntValueField]);
            }
            else
                SetFocus (hwndEnt[EntKeyField]);
        }
        if (LOWORD(wParam) == VK_RETURN)
        {
            if (hwnd == hwndEnt[EntKeyField])
            {
                SendMessage (hwndEnt[EntValueField], WM_SETTEXT, 0, (long)"");
                SetFocus (hwndEnt[EntValueField]);
            }
            else
            {
                AddProp ();
                SetFocus (g_qeglobals.d_hwndCamera);
            }
        }
        break;
//  case WM_NCHITTEST:
    case WM_LBUTTONDOWN:
        SetFocus (hwnd);
        break;
    }
    return CallWindowProc (OldFieldWindowProc, hwnd, uMsg, wParam, lParam);
}


/*
=========================
EntityListWndProc

Just to handle enter...
=========================
*/
BOOL CALLBACK EntityListWndProc(
    HWND hwnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_KEYDOWN:
        if (LOWORD(wParam) == VK_RETURN)
        {
            SendMessage ( g_qeglobals.d_hwndEntity, 
                          WM_COMMAND, 
                          (LBN_DBLCLK<<16) + IDC_E_LIST, 
                          0 );
            return 0;
        }
        break;
    }
    return CallWindowProc (OldEntityListWindowProc, hwnd, uMsg, wParam, lParam);
}


/*
================
GetEntityControls

Finds the controls from the dialog and
moves them to the window
================
*/
void GetEntityControls(HWND ghwndEntity)
{
    int i;

    for (i = 0; i < EntLast; i++)
    {
        if (i == EntList || i == EntProps || i == EntComment)
            continue;
        if (i == EntKeyField || i == EntValueField)
            continue;
        hwndEnt[i] = GetDlgItem(ghwndEntity, rgIds[i]);     
        if (hwndEnt[i])
    {
            SetParent (hwndEnt[i], g_qeglobals.d_hwndEntity );
            SendMessage(hwndEnt[i], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    }
    }


    // SetParent apears to not modify some internal state
    // on listboxes, so create it from scratch...

    hwndEnt[EntList] = CreateWindow ("listbox", NULL, 
        LBS_STANDARD | LBS_NOINTEGRALHEIGHT | LBS_WANTKEYBOARDINPUT 
        | WS_VSCROLL | WS_CHILD | WS_VISIBLE,
        5, 5, 180, 99,
        g_qeglobals.d_hwndEntity,
        (HMENU)IDC_E_LIST,
        g_qeglobals.d_hInstance,
        NULL);
    if (!hwndEnt[EntList])
        Error ("CreateWindow failed");

    hwndEnt[EntProps] = CreateWindow ("listbox", NULL, 
        LBS_STANDARD | LBS_NOINTEGRALHEIGHT | LBS_USETABSTOPS
        | WS_VSCROLL | WS_CHILD | WS_VISIBLE,
        5, 100, 180, 99,
        g_qeglobals.d_hwndEntity,
        (HMENU)IDC_E_PROPS,
        g_qeglobals.d_hInstance,
        NULL);
    if (!hwndEnt[EntProps])
        Error ("CreateWindow failed");

    hwndEnt[EntComment] = CreateWindow ("edit", NULL, 
        ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER,
        5, 100, 180, 99,
        g_qeglobals.d_hwndEntity,
        (HMENU)IDC_E_COMMENT,
        g_qeglobals.d_hInstance,
        NULL);
    if (!hwndEnt[EntComment])
        Error ("CreateWindow failed");

    hwndEnt[EntKeyField] = CreateWindow ("edit", NULL, 
        WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
        5, 100, 180, 99,
        g_qeglobals.d_hwndEntity,
        (HMENU)IDC_E_KEY_FIELD,
        g_qeglobals.d_hInstance,
        NULL);
    if (!hwndEnt[EntKeyField])
        Error ("CreateWindow failed");

    hwndEnt[EntValueField] = CreateWindow ("edit", NULL, 
        WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
        5, 100, 180, 99,
        g_qeglobals.d_hwndEntity,
        (HMENU)IDC_E_VALUE_FIELD,
        g_qeglobals.d_hInstance,
        NULL);
    if (!hwndEnt[EntValueField])
        Error ("CreateWindow failed");

  g_wndTabs.SubclassDlgItem(IDC_TAB_MODE, CWnd::FromHandle(ghwndEntity));
  hwndEnt[EntTab] = g_wndTabs.GetSafeHwnd();
  g_wndTabs.InsertItem(0, "Groups");
  ::SetParent(g_wndTabs.GetSafeHwnd(), g_qeglobals.d_hwndEntity);

  if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
  {
      g_qeglobals.d_hwndEdit = CreateWindow ("edit", NULL, ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER,
                                               5, 100, 180, 99, g_qeglobals.d_hwndEntity, (HMENU)IDC_E_STATUS,
                                               g_qeglobals.d_hInstance, NULL);
      if (!g_qeglobals.d_hwndEdit)
          Error ("CreateWindow failed");
    g_wndTabs.InsertItem(0, "Console");
    g_wndTabs.InsertItem(0, "Textures");
  }
  g_wndTabs.InsertItem(0, "Entities");
  g_wndTabs.ShowWindow(SW_SHOW);

#if 0
    for (i=0 ; i<12 ; i++)
    {
        hwndEnt[EntCheck1 + i] = CreateWindow ("button", NULL, 
        BS_AUTOCHECKBOX | WS_CHILD | WS_VISIBLE,
        5, 100, 180, 99,
        entwindow,
        (HMENU)IDC_E_STATUS,
        main_instance,
        NULL);
        if (!hwndEnt[EntCheck1 + i])
            Error ("CreateWindow failed");
    }
#endif
    SendMessage(hwndEnt[EntList], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    SendMessage(hwndEnt[EntProps], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    SendMessage(hwndEnt[EntComment], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    SendMessage(hwndEnt[EntKeyField], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    SendMessage(hwndEnt[EntValueField], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
    SendMessage(hwndEnt[EntTab], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);

    if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
        SendMessage(g_qeglobals.d_hwndEdit, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), (LPARAM)TRUE);
}



/*
===============================================================

ENTITY WINDOW

===============================================================
*/


void FillClassList (void)
{
    eclass_t    *pec;
    int         iIndex;

    SendMessage(hwndEnt[EntList], LB_RESETCONTENT, 0 , 0);

    for (pec = eclass ; pec ; pec = pec->next)
    {
        iIndex = SendMessage(hwndEnt[EntList], LB_ADDSTRING, 0 , (LPARAM)pec->name);
        SendMessage(hwndEnt[EntList], LB_SETITEMDATA, iIndex, (LPARAM)pec);
    }   

}


/*
==============
WEnt_Create
==============
*/
void WEnt_Create (HINSTANCE hInstance)
{
    WNDCLASS   wc;

    /* Register the camera class */
    memset (&wc, 0, sizeof(wc));

    wc.style         = CS_NOCLOSE | CS_OWNDC;
    wc.lpfnWndProc   = (WNDPROC)EntityWndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = 0;
    wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject (LTGRAY_BRUSH);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = ENT_WINDOW_CLASS;

    RegisterClass (&wc);

    int nStyle = (g_pParentWnd->CurrentStyle() == QR_QE4) ? QE3_STYLE : QE3_STYLE2;
      g_qeglobals.d_hwndEntity = CreateWindow (ENT_WINDOW_CLASS ,
        "Entity",
        nStyle,
        20,
        20,
        100,
        480,    // size

        g_qeglobals.d_hwndMain, // parent
        0,      // no menu
        hInstance,
        NULL);

    if (!g_qeglobals.d_hwndEntity )
        Error ("Couldn't create Entity window");
}

/*
==============
CreateEntityWindow
==============
*/
BOOL CreateEntityWindow(HINSTANCE hInstance)
{
    HWND hwndEntityPalette;

    inspector_mode = W_ENTITY;

    WEnt_Create (hInstance);

    hwndEntityPalette = CreateDialog(hInstance, (char *)IDD_ENTITY, g_qeglobals.d_hwndMain, (DLGPROC)NULL);
    if (!hwndEntityPalette)
        Error ("CreateDialog failed");

    GetEntityControls (hwndEntityPalette);
    DestroyWindow (hwndEntityPalette);

    OldFieldWindowProc = (WNDPROC)GetWindowLong (hwndEnt[EntKeyField], GWL_WNDPROC);
    SetWindowLong (hwndEnt[EntKeyField], GWL_WNDPROC, (long)FieldWndProc);
    SetWindowLong (hwndEnt[EntValueField], GWL_WNDPROC, (long)FieldWndProc);

    OldEntityListWindowProc = (WNDPROC)GetWindowLong (hwndEnt[EntList], GWL_WNDPROC);
    SetWindowLong (hwndEnt[EntList], GWL_WNDPROC, (long)EntityListWndProc);

    FillClassList ();


    LoadWindowPlacement(g_qeglobals.d_hwndEntity, "EntityWindowPlace");
    ShowWindow (g_qeglobals.d_hwndEntity, SW_HIDE);
    SetInspectorMode (W_CONSOLE);

    return TRUE;
}

/*
==============
SetInspectorMode
==============
*/
void SetInspectorMode(int iType)
{
    RECT rc;
    HMENU hMenu = GetMenu( g_qeglobals.d_hwndMain );

  if ((g_pParentWnd->CurrentStyle() == QR_SPLIT || g_pParentWnd->CurrentStyle() == QR_SPLITZ) && (iType == W_TEXTURE || iType == W_CONSOLE))
    return;


    // Is the caller asking us to cycle to the next window?

    if (iType == -1)
    {
        if (inspector_mode == W_ENTITY)
            iType = W_TEXTURE;
        else if (inspector_mode == W_TEXTURE)
            iType = W_CONSOLE;
        else if (inspector_mode == W_CONSOLE)
      iType = W_GROUP;
    else
            iType = W_ENTITY;
    }       

    inspector_mode = iType;
    switch(iType)
    {
        
    case W_ENTITY:
        SetWindowText(g_qeglobals.d_hwndEntity, "Entity");
        EnableMenuItem( hMenu, ID_MISC_SELECTENTITYCOLOR, MF_ENABLED | MF_BYCOMMAND );
    // entity is always first in the inspector
    g_wndTabs.SetCurSel(0);
        break;

    case W_TEXTURE:
    SetWindowText(g_qeglobals.d_hwndEntity, "Textures");
    g_pParentWnd->GetTexWnd()->FocusEdit();
        EnableMenuItem( hMenu, ID_MISC_SELECTENTITYCOLOR, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND );
    if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
      g_wndTabs.SetCurSel(1);
        break;

    case W_CONSOLE:
        SetWindowText(g_qeglobals.d_hwndEntity, "Console");     
        EnableMenuItem( hMenu, ID_MISC_SELECTENTITYCOLOR, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND );
    if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
      g_wndTabs.SetCurSel(2);
        break;

  case W_GROUP:
        SetWindowText(g_qeglobals.d_hwndEntity, "Groups");      
        EnableMenuItem( hMenu, ID_MISC_SELECTENTITYCOLOR, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND );
    if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
      g_wndTabs.SetCurSel(3);
    else
      g_wndTabs.SetCurSel(1);
        break;


    default:
        break;
    }

    GetWindowRect (g_qeglobals.d_hwndEntity, &rc);
    SizeEntityDlg( rc.right - rc.left - 8, rc.bottom - rc.top - 20);


//  InvalidateRect(entwindow, NULL, true);
//  ShowWindow (entwindow, SW_SHOW);
//  UpdateWindow (entwindow);

  HWND hFlag = (g_pParentWnd->CurrentStyle() == QR_QE4) ? HWND_TOP : HWND_TOPMOST;
    SetWindowPos( g_qeglobals.d_hwndEntity, hFlag, rc.left, rc.top,  rc.right - rc.left, rc.bottom - rc.top, SWP_NOSIZE | SWP_NOMOVE );
    RedrawWindow (g_qeglobals.d_hwndEntity, NULL, NULL, RDW_ERASE | RDW_INVALIDATE| RDW_ERASENOW | RDW_UPDATENOW | RDW_ALLCHILDREN);
}





// SetKeyValuePairs
//
// Reset the key/value (aka property) listbox and fill it with the 
// k/v pairs from the entity being edited.
//

void SetKeyValuePairs (bool bClearMD3)
{
    epair_t *pep;
    RECT    rc;
    char    sz[4096];
    
    if (edit_entity == NULL)
        return;
    
    // set key/value pair list
    
    GetWindowRect(hwndEnt[EntProps], &rc);
    SendMessage(hwndEnt[EntProps], LB_SETCOLUMNWIDTH, (rc.right - rc.left)/2, 0);
    SendMessage(hwndEnt[EntProps], LB_RESETCONTENT, 0, 0);
    
    // Walk through list and add pairs
    
    for (pep = edit_entity->epairs ; pep ; pep = pep->next)
    {
        // if the key is less than 8 chars, add a tab for alignment
        if (strlen(pep->key) > 8)
            sprintf (sz, "%s\t%s", pep->key, pep->value);
        else
            sprintf (sz, "%s\t\t%s", pep->key, pep->value);
        SendMessage(hwndEnt[EntProps], LB_ADDSTRING, 0, (LPARAM)sz);
    }
    
    if (edit_entity->eclass->nShowFlags & ECLASS_MISCMODEL)
    {
        // if this is a misc_model
        // cache the md3 for display later
        if (bClearMD3)
        {
            edit_entity->md3Class = NULL;
        }
        //char *pModel = ValueForKey(edit_entity, "model");
        
        /*
        if (pModel != NULL)
        {
        GetCachedModel(pModel, vMin, vMax);
        }
        */
    }
        
    Sys_UpdateWindows(W_CAMERA | W_XY);
    
}

// SetSpawnFlags
// 
// Update the checkboxes to reflect the flag state of the entity
//
void SetSpawnFlags(void)
{
    int     f;
    int     i;
    int     v;

    f = atoi(ValueForKey (edit_entity, "spawnflags"));
    for (i=0 ; i<12 ; i++)
    {
        v = !!(f&(1<<i));
        SendMessage(hwndEnt[EntCheck1+i], BM_SETCHECK, v, 0);
    }
}


// GetSpawnFlags
// 
// Update the entity flags to reflect the state of the checkboxes
//
void GetSpawnFlags(void)
{
    int     f;
    int     i, v;
    char    sz[32];

    f = 0;
    for (i=0 ; i<12 ; i++)
    {
        v = SendMessage(hwndEnt[EntCheck1+i], BM_GETCHECK, 0, 0);
        f |= v<<i;
    }

    sprintf (sz, "%i", f);

    if (multiple_entities)
    {
        brush_t *b;

        for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
            SetKeyValue(b->owner, "spawnflags", sz);
    }
    else
        SetKeyValue (edit_entity, "spawnflags", sz);
    SetKeyValuePairs ();
}

// UpdateSel
//
// Update the listbox, checkboxes and k/v pairs to reflect the new selection
//
BOOL UpdateSel(int iIndex, eclass_t *pec)
{
    int     i;
    brush_t *b;

    if (selected_brushes.next == &selected_brushes)
    {
        edit_entity = world_entity;
        multiple_entities = false;
    }
    else
    {
        edit_entity = selected_brushes.next->owner;
        for (b=selected_brushes.next->next ; b != &selected_brushes ; b=b->next)
        {
            if (b->owner != edit_entity)
            {
                multiple_entities = true;
                break;
            }
        }
    }

    if (iIndex != LB_ERR)
        SendMessage(hwndEnt[EntList], LB_SETCURSEL, iIndex, 0);

    if (pec == NULL)
        return TRUE;

    // Set up the description

    SendMessage(hwndEnt[EntComment], WM_SETTEXT, 0, 
            (LPARAM)TranslateString(pec->comments));

    for (i=0 ; i<8 ; i++)
    {
        HWND hwnd = hwndEnt[EntCheck1+i];
        if (pec->flagnames[i] && pec->flagnames[i][0] != 0)
        {
            EnableWindow(hwnd, TRUE);
            SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)pec->flagnames[i]);
        } else {

            // disable check box
            SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM)" ");
            EnableWindow(hwnd, FALSE);
        }
    }

    SetSpawnFlags();
    SetKeyValuePairs();
    return TRUE;
}

BOOL UpdateEntitySel(eclass_t *pec)
{
    int iIndex;

    iIndex = (int)SendMessage(hwndEnt[EntList], LB_FINDSTRINGEXACT, 
            (WPARAM)-1, (LPARAM)pec->name);

    return UpdateSel(iIndex, pec);
}

// CreateEntity
//
// Creates a new entity based on the currently selected brush and entity type.
//

void CreateEntity(void)
{
    eclass_t *pecNew;
    entity_t *petNew;
    int i;
    HWND hwnd;
    char sz[1024];

    // check to make sure we have a brush

    if (selected_brushes.next == &selected_brushes)
    {
        MessageBox(g_qeglobals.d_hwndMain, "You must have a selected brush to create an entity"
            , "info", 0);
        return;
    }


    // find out what type of entity we are trying to create

    hwnd = hwndEnt[EntList];

    i = SendMessage(hwndEnt[EntList], LB_GETCURSEL, 0, 0);

    if (i < 0)
    {
        MessageBox(g_qeglobals.d_hwndMain, "You must have a selected class to create an entity"
            , "info", 0);
        return;
    }

    SendMessage(hwnd, LB_GETTEXT, i, (LPARAM)sz);

    if (!stricmp(sz, "worldspawn"))
    {
        MessageBox(g_qeglobals.d_hwndMain, "Can't create an entity with worldspawn.", "info", 0);
        return;
    }

    pecNew = Eclass_ForName(sz, false);

    // create it

    petNew = Entity_Create(pecNew);

    if (petNew == NULL)
    {
        MessageBox(g_qeglobals.d_hwndMain, "Failed to create entity.", "info", 0);
        return;
    }

    if (selected_brushes.next == &selected_brushes)
        edit_entity = world_entity;
    else
        edit_entity = selected_brushes.next->owner;

    SetKeyValuePairs();
    Select_Deselect ();
    Select_Brush (edit_entity->brushes.onext);
  Sys_UpdateWindows(W_ALL);

}



/*
===============
AddProp

===============
*/
void AddProp()
{
    char    key[4096];
    char    value[4096];

    if (edit_entity == NULL)
        return;

    // Get current selection text

    SendMessage(hwndEnt[EntKeyField], WM_GETTEXT, sizeof(key)-1, (LPARAM)key);  
    SendMessage(hwndEnt[EntValueField], WM_GETTEXT, sizeof(value)-1, (LPARAM)value);    

    if (multiple_entities)
    {
        brush_t *b;

        for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
            SetKeyValue(b->owner, key, value);
    }
    else
        SetKeyValue(edit_entity, key, value);

    // refresh the prop listbox
    SetKeyValuePairs(); 

    // if it's a plugin entity, perhaps we need to update some drawing parameters
    // NOTE: perhaps moving this code to a seperate func would help if we need it in other places
    // TODO: we need to call some update func in the IPluginEntity in case model name changes etc.
    // ( for the moment only bounding brush is updated ), see UpdateModelBrush in Ritual's Q3Radiant
    if (edit_entity->eclass->nShowFlags & ECLASS_PLUGINENTITY)
    {
        vec3_t  mins, maxs;
        edit_entity->pPlugEnt->GetBounds( mins, maxs );
        // replace old bounding brush by newly computed one
        // NOTE: this part is similar to Entity_BuildModelBrush in Ritual's Q3Radiant, it can be
        // usefull moved into a seperate func
        brush_t *b,*oldbrush;
        if (edit_entity->brushes.onext != &edit_entity->brushes)
            oldbrush = edit_entity->brushes.onext;
        b = Brush_Create (mins, maxs, &edit_entity->eclass->texdef);
        Entity_LinkBrush (edit_entity, b);
        Brush_Build( b, true );
        Select_Deselect();
        Brush_AddToList (edit_entity->brushes.onext, &selected_brushes);
        if (oldbrush)
            Brush_Free( oldbrush );
    }

}

/*
===============
DelProp

===============
*/
void DelProp(void)
{
    char    sz[4096];

    if (edit_entity == NULL)
        return;

    // Get current selection text

    SendMessage(hwndEnt[EntKeyField], WM_GETTEXT, sizeof(sz)-1, (LPARAM)sz);    

    if (multiple_entities)
    {
        brush_t *b;

        for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
            DeleteKey(b->owner, sz);
    }
    else
        DeleteKey(edit_entity, sz);

    // refresh the prop listbox

    SetKeyValuePairs(); 
}

BOOL GetSelectAllCriteria(CString &strKey, CString &strVal) {
    char    sz[4096];
    HWND hwnd = hwndEnt[EntProps];
    int i = SendMessage(hwnd, LB_GETCURSEL, 0, 0);  
  if (i >= 0 && inspector_mode == W_ENTITY) {
      SendMessage(hwndEnt[EntKeyField], WM_GETTEXT, sizeof(sz), (LPARAM)sz);    
    strKey = sz;
      SendMessage(hwndEnt[EntValueField], WM_GETTEXT, sizeof(sz), (LPARAM)sz);  
    strVal = sz;
    return TRUE;
  }
  return FALSE;
}

/*
===============
EditProp

===============
*/
void EditProp(void)
{
    int i;
    HWND hwnd;
    char    sz[4096];
    char    *val;

    if (edit_entity == NULL)
        return;

    hwnd = hwndEnt[EntProps];

    // Get current selection text

    i = SendMessage(hwnd, LB_GETCURSEL, 0, 0);  

    if (i < 0)
        return;

    SendMessage(hwnd, LB_GETTEXT, i, (LPARAM)sz);   

    // strip it down to the key name

    for(i=0;sz[i] != '\t';i++)
    ;

    sz[i] = '\0';

    val = sz + i + 1;
    if (*val == '\t')
        val++;

    SendMessage(hwndEnt[EntKeyField], WM_SETTEXT, 0, (LPARAM)sz);   
    SendMessage(hwndEnt[EntValueField], WM_SETTEXT, 0, (LPARAM)val);    
}


HDWP    defer;
int     col;
void MOVE(HWND e, int x, int y, int w, int h, HWND hwndPlacement = HWND_TOP, int swp = SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOZORDER)
{
//  defer=DeferWindowPos(defer,e,HWND_TOP,col+(x),y,w,h,SWP_SHOWWINDOW);
//  MoveWindow (e, col+x, y, w, h, FALSE);
    SetWindowPos (e, hwndPlacement, col+x, y, w, h, swp);
}


/*
===============
SizeEnitityDlg

Positions all controls so that the active inspector
is displayed correctly and the inactive ones are
off the side
===============
*/
void SizeEntityDlg(int iWidth, int iHeight)
{
    int y, x, xCheck, yCheck;
    int i, iRow;
    int w, h;

    if (iWidth < 32 || iHeight < 32)
        return;

    SendMessage( g_qeglobals.d_hwndEntity, WM_SETREDRAW, 0, 0);
  iHeight -= 24;


    //==========================================


  //
    // console
    //
  if (inspector_mode == W_CONSOLE)
  {
    col = 0;
  }
  else
  {
    col = iWidth;
  }

  if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
      MOVE(g_qeglobals.d_hwndEdit,  DlgXBorder, DlgYBorder, iWidth - (2 * DlgXBorder), iHeight - (2 * DlgYBorder) );

    //==========================================

    //
    // texture controls
    //
  if (inspector_mode == W_TEXTURE)
  {
    col = 0;
  }
  else
  {
    col = iWidth;
  }

  if (g_pParentWnd->CurrentStyle() > 0 && g_pParentWnd->CurrentStyle() < 3)
      MOVE(g_qeglobals.d_hwndTexture,   DlgXBorder, DlgYBorder, iWidth - (2 * DlgXBorder), iHeight - (2 * DlgYBorder) );

  if (inspector_mode == W_GROUP)
  {
    col = 0;
  }
  else
  {
    col = iWidth;
  }

  MOVE(g_qeglobals.d_hwndGroup, DlgXBorder, DlgYBorder, iWidth - (2 * DlgXBorder), iHeight - (2 * DlgYBorder) );

    //==========================================

    //
    // entity controls
    //
  if (inspector_mode == W_ENTITY)
  {
    col = 0;
  }
  else
  {
    col = iWidth;
  }



    // top half includes the entity list (2/3) and the 
    // comments (1/3) - 2 gaps, above and below.

    y = iHeight/2;
    y -= 2 * DlgYBorder;
    y = y / 3;
    w = iWidth - (2 * DlgXBorder);
    MOVE(hwndEnt[EntList], DlgXBorder, DlgYBorder, w, 2 * y);
    
    MOVE(hwndEnt[EntComment], DlgXBorder, 2 * DlgYBorder + 2 * y, w, y - (2 * DlgYBorder));

    // bottom half includes flags (fixed), k/v pairs,
    // and buttons (fixed).

    // xCheck = width of a single check box
    // yCheck = distance from top of one check to the next

    xCheck = (iWidth - (2 * DlgXBorder)) / 3;
    yCheck = 18;

    x = DlgXBorder;

    for (iRow = 0; iRow <= 12; iRow += 4)
    {
        y = iHeight/2;
    
        for (i = 0; i < 4; i++)
        {
            MOVE(hwndEnt[EntCheck1 + i + iRow],
                x, y, xCheck, yCheck);
            y += yCheck;
        }

        x += xCheck;
    }

    //
    // properties scroll box
    //
    y = iHeight/2 + 4 * yCheck;

    w = iWidth - (2 * DlgXBorder);
    h = (iHeight - (yCheck * 5 + 2 * DlgYBorder) ) - y;

    MOVE(hwndEnt[EntProps], DlgXBorder, y, w, h);

    y += h + DlgYBorder;
    
    //
    // key / value fields
    //
    w = iWidth-(DlgXBorder+45);
    MOVE(hwndEnt[EntKeyLabel], DlgXBorder, y, 40, yCheck);
    MOVE(hwndEnt[EntKeyField], DlgXBorder+40, y, w, yCheck);
    y += yCheck;        

    MOVE(hwndEnt[EntValueLabel], DlgXBorder, y, 40, yCheck);
    MOVE(hwndEnt[EntValueField], DlgXBorder+40, y, w, yCheck);
    y += yCheck;        

    //
    // angle check boxes
    //
  y += 2;
    i = y;
    x = DlgXBorder;

    xCheck = yCheck*2;

    MOVE(hwndEnt[EntDir135], x, y, xCheck, yCheck);
    y += yCheck;        
    
    MOVE(hwndEnt[EntDir180], x, y, xCheck, yCheck);
    y += yCheck;        
    
    MOVE(hwndEnt[EntDir225], x, y, xCheck, yCheck);

    y = i;
    x += xCheck;

    
    MOVE(hwndEnt[EntDir90], x, y, xCheck, yCheck);
    y += yCheck;        
    y += yCheck;        
    
    MOVE(hwndEnt[EntDir270], x, y, xCheck, yCheck);

    y = i;
    x += xCheck;

    
    MOVE(hwndEnt[EntDir45], x, y, xCheck, yCheck);
    y += yCheck;        
    
    MOVE(hwndEnt[EntDir0], x, y, xCheck, yCheck);
    y += yCheck;        
    
    MOVE(hwndEnt[EntDir315], x, y, xCheck, yCheck);

    y = i + yCheck/2;
    x += xCheck + xCheck/2;

    
    MOVE(hwndEnt[EntDirUp], x, y, xCheck, yCheck);
    y += yCheck;        
    
    MOVE(hwndEnt[EntDirDown], x, y, xCheck, yCheck);

    y = i;
    x += 1.5 * xCheck;
    
    MOVE(hwndEnt[EntDelProp], x, y, xCheck*2, yCheck);
    y += yCheck + 4;        

  MOVE(hwndEnt[EntAssignSounds], x, y, xCheck*2, yCheck);
    y += yCheck;        
  MOVE(hwndEnt[EntAssignModels], x, y, xCheck*2, yCheck);

  // tab selector is always visible
  col = 0;
  iHeight += 24;
  MOVE(hwndEnt[EntTab], 0,0,iWidth,iHeight, HWND_BOTTOM, SWP_NOACTIVATE | SWP_NOCOPYBITS);

    SendMessage( g_qeglobals.d_hwndEntity, WM_SETREDRAW, 1, 0);
//  InvalidateRect(entwindow, NULL, TRUE);
}

void AssignSound()
{
  CString strBasePath = ValueForKey(g_qeglobals.d_project_entity, "basepath");
  AddSlash(strBasePath);
  CString strPath = strBasePath;
  strPath += "sound\\";

  CWaveOpen dlgFile(TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, "Sound files (*.wav)|*.wav||", g_pParentWnd);
  dlgFile.m_ofn.lpstrInitialDir = strPath;
  if (dlgFile.DoModal() == IDOK)
  {
      SendMessage(hwndEnt[EntKeyField], WM_SETTEXT, 0, (LPARAM)"noise");    
    CString str = dlgFile.GetPathName().GetBuffer(0);
    str.MakeLower();
    strBasePath.MakeLower();
    QE_ConvertDOSToUnixName(str.GetBuffer(0), str.GetBuffer(0));
    QE_ConvertDOSToUnixName(strBasePath.GetBuffer(0), strBasePath.GetBuffer(0));
    int n = str.Find(strBasePath);
    if (n == 0)
    {
      str = str.Right(str.GetLength() - strBasePath.GetLength());
    }

      SendMessage(hwndEnt[EntValueField], WM_SETTEXT, 0, (LPARAM)str.GetBuffer(0)); 
    AddProp();
    g_pParentWnd->GetXYWnd()->SetFocus();
  }
}

void AssignModel()
{
  CString strBasePath = ValueForKey(g_qeglobals.d_project_entity, "basepath");
  AddSlash(strBasePath);
  CString strPath = strBasePath;
  strPath += "models\\mapobjects\\";

  CFileDialog dlgFile(TRUE, NULL, NULL, OFN_OVERWRITEPROMPT, "Model files (*.md3)|*.md3||", g_pParentWnd);
  dlgFile.m_ofn.lpstrInitialDir = strPath;
  if (dlgFile.DoModal() == IDOK)
  {
      SendMessage(hwndEnt[EntKeyField], WM_SETTEXT, 0, (LPARAM)"model");
    CString str = dlgFile.GetPathName().GetBuffer(0);
    str.MakeLower();
    strBasePath.MakeLower();
    QE_ConvertDOSToUnixName(str.GetBuffer(0), str.GetBuffer(0));
    QE_ConvertDOSToUnixName(strBasePath.GetBuffer(0), strBasePath.GetBuffer(0));
    int n = str.Find(strBasePath);
    if (n == 0)
    {
      str = str.Right(str.GetLength() - strBasePath.GetLength());
    }

      SendMessage(hwndEnt[EntValueField], WM_SETTEXT, 0, (LPARAM)str.GetBuffer(0)); 
    AddProp();
    edit_entity->md3Class = NULL;
    edit_entity->brushes.onext->bModelFailed = false;
    g_pParentWnd->GetXYWnd()->SetFocus();
  }
}


/*
=========================
EntityWndProc
=========================
*/
BOOL CALLBACK EntityWndProc(
    HWND hwndDlg,   // handle to dialog box
    UINT uMsg,      // message
    WPARAM wParam,  // first message parameter
    LPARAM lParam)  // second message parameter
{
  LPNMHDR lpnmh = NULL;
    RECT    rc;

    GetClientRect(hwndDlg, &rc);

    switch (uMsg)
    {

      case WM_CHAR :
      {
        char c = toupper(LOWORD(wParam));
        // escape: hide the window
            if (c == 27)
                ShowWindow(hwndDlg, SW_HIDE);
        if (c == 'N')
          g_pParentWnd->PostMessage(WM_COMMAND, ID_VIEW_ENTITY, 0);
        else
        if (c == 'O')
          g_pParentWnd->PostMessage(WM_COMMAND, ID_VIEW_CONSOLE, 0);
        else
        if (c == 'T')
          g_pParentWnd->PostMessage(WM_COMMAND, ID_VIEW_TEXTURE, 0);
        else
        if (c == 'G')
          g_pParentWnd->PostMessage(WM_COMMAND, ID_VIEW_GROUPS, 0);
        else
                DefWindowProc (hwndDlg, uMsg, wParam, lParam);
        break;
      }

      case WM_NOTIFY:
        lpnmh = reinterpret_cast<LPNMHDR>(lParam);
        if (lpnmh->hwndFrom == g_wndTabs.GetSafeHwnd()) {
          if ( lpnmh->code == TCN_SELCHANGE)
          {
            int n = g_wndTabs.GetCurSel();
            if (g_pParentWnd->CurrentStyle() == 2 || g_pParentWnd->CurrentStyle() == 1)
            {
              if (n == 0) {
                SetInspectorMode(W_ENTITY);
              } else if (n == 1) {
                SetInspectorMode(W_TEXTURE);
              } else if (n == 2) {
                SetInspectorMode(W_CONSOLE);
              } else {
                SetInspectorMode(W_GROUP);
              }
            }
            else
            {
              if (n == 0) {
                SetInspectorMode(W_ENTITY);
              } else if (n == 1) {
                SetInspectorMode(W_GROUP);
              }
            }
          }
        }
        break;
        
    case WM_SIZE:

            DefWindowProc (hwndDlg, uMsg, wParam, lParam);
      break;

  case WM_DESTROY:
      SaveWindowPlacement(g_qeglobals.d_hwndEntity, "EntityWindowPlace");
      DefWindowProc(hwndDlg, uMsg, wParam, lParam);
      break;

    case WM_GETMINMAXINFO:
        {
            LPMINMAXINFO    lpmmi;

            lpmmi = (LPMINMAXINFO) lParam;
            lpmmi->ptMinTrackSize.x = 320;
            lpmmi->ptMinTrackSize.y = 500;
        }
        return 0;

    case WM_WINDOWPOSCHANGING:
        {
            LPWINDOWPOS lpwp;
            lpwp = (LPWINDOWPOS) lParam;

            DefWindowProc (hwndDlg, uMsg, wParam, lParam);

            lpwp->flags |= SWP_NOCOPYBITS;
            SizeEntityDlg(lpwp->cx-8, lpwp->cy-32);
            return 0;

        }
        return 0;


    case WM_COMMAND: 
        switch (LOWORD(wParam)) { 

    case IDC_BTN_ASSIGNSOUND:
      AssignSound();
      break;

    case IDC_BTN_ASSIGNMODEL:
      AssignModel();
      break;

        case IDC_E_DELPROP:
            DelProp();
            SetFocus (g_qeglobals.d_hwndCamera);
            break;

        case IDC_E_0:
            SetKeyValue (edit_entity, "angle", "360");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_45:
            SetKeyValue (edit_entity, "angle", "45");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_90:
            SetKeyValue (edit_entity, "angle", "90");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_135:
            SetKeyValue (edit_entity, "angle", "135");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_180:
            SetKeyValue (edit_entity, "angle", "180");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_225:
            SetKeyValue (edit_entity, "angle", "225");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_270:
            SetKeyValue (edit_entity, "angle", "270");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_315:
            SetKeyValue (edit_entity, "angle", "315");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_UP:
            SetKeyValue (edit_entity, "angle", "-1");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;
        case IDC_E_DOWN:
            SetKeyValue (edit_entity, "angle", "-2");
            SetFocus (g_qeglobals.d_hwndCamera);
            SetKeyValuePairs ();
            break;

    case IDC_BTN_HIDE:
      ::PostMessage(g_qeglobals.d_hwndMain, WM_COMMAND, ID_VIEW_CAMERATOGGLE, 0);
      break;

        case IDC_CHECK1:
        case IDC_CHECK2:
        case IDC_CHECK3:
        case IDC_CHECK4:
        case IDC_CHECK5:
        case IDC_CHECK6:
        case IDC_CHECK7:
        case IDC_CHECK8:
        case IDC_CHECK9:
        case IDC_CHECK10:
        case IDC_CHECK11:
        case IDC_CHECK12:
            GetSpawnFlags();
            SetFocus (g_qeglobals.d_hwndCamera);
            break;


        case IDC_E_PROPS: 
            switch (HIWORD(wParam))
            { 
            case LBN_SELCHANGE:

                EditProp();
                return TRUE; 
            }
            break;

        case IDC_E_LIST: 
       
            switch (HIWORD(wParam)) { 
            
            case LBN_SELCHANGE: 
            {
                int iIndex;
                eclass_t *pec;
                
                iIndex = SendMessage(hwndEnt[EntList], LB_GETCURSEL, 0, 0); 
                pec = (eclass_t *)SendMessage(hwndEnt[EntList], LB_GETITEMDATA, 
                        iIndex, 0); 
            
                UpdateSel(iIndex, pec);

                return TRUE; 
                break; 
            }

            case LBN_DBLCLK: 
                CreateEntity ();
                SetFocus (g_qeglobals.d_hwndCamera);
                break; 
            } 
            break; 


            default: 
              return DefWindowProc( hwndDlg, uMsg, wParam, lParam ); 
        } 

        return 0;
    }

    return DefWindowProc (hwndDlg, uMsg, wParam, lParam);
}

---