#include "StdAfx.h"
#include "ToolPalette.h"
#include "ToolPaletteItem.h"
#include "../../../T2DLL/T2BitImage.h"
#include "../../../T2DLL/T2ImageObj.h"
#include "../../../T2DLL/T2PaletteAnimeDef.h"
#include "../../../T2DLL/T2ToolDef.h"
#include "../../../T2DLL/T2ToolHelpWnd.h"
#include "../../../T2DLL/T2WorldDef.h"
#include "../../../T2TowerDoc.h"

ToolPalette::ToolPalette() {
    mSize130.cx = 26;
    mSize130.cy = 26;

    mSize138.cx = 76;
    mSize138.cy = 13;

    m140 = 16;
    m144 = 3;
    m148 = 4;
    m124 = 0;

    mImageObj = NULL;
    mImage = NULL;
    mToolHelpWnd = NULL;

    _184 = -1;
}

/*virtual*/ ToolPalette::~ToolPalette() {
    int i;

    for (i = 0; i < kNumCommand; i++)
        delete mCommands[i];

    delete mCategoryTitle;
    for (i = 0; i < kNumCategory; i++)
        delete mCategories[i];
    delete mCategoryScroll;

    delete mToolTitle;
    for (i = 0; i < kNumTool; i++)
        delete mTools[i];
    delete mToolScroll;

    if (mImageObj)
        delete mImageObj;
    if (mImage)
        delete mImage;

    POSITION pos = mHistoryList.GetHeadPosition();
    while (pos)
        delete mHistoryList.GetNext(pos);
}

/*virtual*/ void ToolPalette::ItemCallbackDown(ToolPaletteItem *inItem) {
    if (inItem->GetMode() != kTPIMode1)
        return;

    T2ToolIconItem *icon = inItem->GetIcon();
    if (icon->mEnableCount > 0)
        return;
    if (icon->m30 == 0)
        return;

    T2ToolIconItem *changeIcon = ChangeIconItem(icon);
    if (changeIcon && changeIcon->mToolCallback) {
        T2ToolCallback *theToolCallback = changeIcon->mToolCallback;
        theToolCallback->toolCallback_vf00(this, changeIcon);
    }

    T2ToolCallback *theToolCallback = icon->mToolCallback;
    if (theToolCallback)
        theToolCallback->toolCallback_vf00(this, icon);

    mClickedItem = icon;
    m15C = (T2ToolDef *) GetIconPlugin(mSel);
    ShowHelpWindow();
}

/*virtual*/ void ToolPalette::ItemCallbackUp(ToolPaletteItem *inItem) {
    if (mTimerID)
        KillTimer(mTimerID);

    HideHelpWindow();

    if (inItem->GetMode() != kTPIMode1)
        return;

    T2ToolIconItem *icon = inItem->GetIcon();
    if (icon->mEnableCount > 0)
        return;
    if (icon->m30 == 0)
        return;

    int i;
    if (icon->m18) {
        icon->m24 = false;

        switch (icon->mOption) {
            case kToolOption0:
                for (i = 0; i < kNumCommand; i++)
                    mCommands[i]->InvalidateRect(NULL);
                break;

            case kToolOption4:
                for (i = 0; i < kNumCategory; i++)
                    mCategories[i]->InvalidateRect(NULL);
                break;

            case kToolOption1:
            case kToolOption2:
            case kToolOption3:
                for (i = 0; i < kNumTool; i++)
                    mTools[i]->InvalidateRect(NULL);
                break;
        }

        T2ToolCallback *theToolCallback = icon->mToolCallback;
        if (theToolCallback)
            theToolCallback->toolCallback_vf00(this, icon);
    }
}

T2ToolIconItem *ToolPalette::ChangeIconItem(T2ToolIconItem *inItem) {
    T2ToolIconItem *result = NULL;

    if (inItem->m18 != 0) {
        inItem->m24 = true;

        int i;
        switch (inItem->mOption) {
            case kToolOption0:
                for (i = 0; i < kNumCommand; i++)
                    mCommands[i]->InvalidateRect(NULL);
                break;
            case kToolOption4:
                for (i = 0; i < kNumCategory; i++)
                    mCategories[i]->InvalidateRect(NULL);
                break;
            case kToolOption1:
            case kToolOption2:
            case kToolOption3:
                for (i = 0; i < kNumTool; i++)
                    mTools[i]->InvalidateRect(NULL);
                break;
        }
    } else {
        T2ToolIconItem *oldItem = GetItem(mSel);
        ToolHistoryItem *history;

        switch (inItem->mOption) {
            case kToolOption0:
                mSel = inItem->mID;
                Updated();
                break;

            case kToolOption4: {
                POSITION pos = mToolIconList->GetHeadPosition();
                T2ToolIconItem *lowItem = NULL;
                T2ToolIconItem *theItem;
                while (pos) {
                    theItem = mToolIconList->GetNext(pos);
                    if (theItem->mOption == kToolOption1 || theItem->mOption == kToolOption2 || theItem->mOption == kToolOption3) {
                        if (((T2ToolDef *) theItem->mPlugin)->mCategoryNo == inItem->mValiation) {
                            if (lowItem) {
                                if (lowItem->mToolDef) {
                                    if (theItem->mToolDef) {
                                        if (theItem->mToolDef->GetSortKey() < lowItem->mToolDef->GetSortKey())
                                            lowItem = theItem;
                                    }
                                } else {
                                    lowItem = theItem;
                                }
                            } else {
                                lowItem = theItem;
                            }
                        }
                    }
                }

#line 330
                _ASSERT(lowItem != NULL);

                theItem = lowItem;
                mSel = theItem->mID;
                history = GetToolHistory(((T2ToolDef *) GetIconPlugin(mSel))->mCategoryNo);

                int theScrollPos = 0;
                if (history->_C != -1) {
                    mSel = history->_C;
                    theScrollPos = history->_8;
                } else {
                    history->_C = mSel;
                    history->_8 = theScrollPos;
                }

                _184 = mSel;
                mToolScroll->SetScrollPos(theScrollPos);
                Updated();
                break;
            }

            case kToolOption1:
            case kToolOption2:
            case kToolOption3:
                mSel = inItem->mID;
                history = GetToolHistory(((T2ToolDef *) GetIconPlugin(mSel))->mCategoryNo);
                history->_8 = mToolScroll->GetScrollPos();
                history->_C = mSel;
                Updated();
                break;
        }
    }

    return result;
}

/*virtual*/ T2ToolIconItem *ToolPalette::EnableIcon(unsigned short inMask) {
    T2ToolIconItem *icon = T2ToolWindow::EnableIcon(inMask);
    if (icon) {
        ChangeIconItem(icon);
        ListUpdated();
    }
    return icon;
}

/*virtual*/ int ToolPalette::OnCreateProc(LPCREATESTRUCT lpCreateStruct) {
#pragma var_order(windowRect, y, rect2, x2, y2, i, clientRect, y3, rect1, x)
    int i;

    mImageObj = new T2ImageObj;
    mImage = new T2BitImage(mModule, 1000, true);
    mImageObj->AddObject(mModule, 1000, mImage);

    for (i = 0; i < kNumCommand; i++)
        mCommands[i] = new ToolPaletteItem(mDocument, kTPIMode1);

    mCategoryTitle = new ToolPaletteItem(mDocument, kTPIMode0);
    for (i = 0; i < kNumCategory; i++)
        mCategories[i] = new ToolPaletteItem(mDocument, kTPIMode1);
    mCategoryScroll = new ToolPaletteItem(mDocument, kTPIMode2);

    mToolTitle = new ToolPaletteItem(mDocument, kTPIMode0);
    for (i = 0; i < kNumTool; i++)
        mTools[i] = new ToolPaletteItem(mDocument, kTPIMode1);
    mToolScroll = new ToolPaletteItem(mDocument, kTPIMode2);

    mWndClass = AfxRegisterWndClass(CS_VREDRAW | CS_HREDRAW | CS_NOCLOSE, NULL, (HBRUSH) GetStockObject(WHITE_BRUSH));

    CRect rect1, rect2;
    int x = 0, y = 0, x2, y2, y3;
    m14C[kToolHelpMode0] = y + 5;

    for (i = 0; i < kNumCommand; i++) {
        x2 = (mSize130.cx - 1) * x + 3;
        y2 = (mSize130.cy - 1) * y + 5;
        rect1.SetRect(x2, y2, x2 + mSize130.cx, y2 + mSize130.cy);
        rect2.UnionRect(rect2, rect1);
        mCommands[i]->Create(mWndClass, "", WS_VISIBLE | WS_CHILD, rect1, this, i + 1000);

        x++;
        if (x >= 3) {
            x = 0;
            y++;
        }
    }

    x2 = 3;
    y = 3;
    y2 += mSize130.cy + 4;
    rect1.SetRect(x2, y2, x2 + mSize130.cx * 3 - 2, y2 + m140 + 2);
    rect2.UnionRect(rect2, rect1);
    mCategoryTitle->Create(mWndClass, "", WS_VISIBLE | WS_CHILD, rect1, this, 1100);

    y2 += m140 + 2;
    m14C[kToolHelpMode1] = y2;

    x = 0;
    y = 0;

    for (i = 0; i < kNumCategory; i++) {
        x2 = (mSize130.cx - 1) * x + 3;
        y3 = y2 + (mSize130.cy - 1) * y;
        rect1.SetRect(x2, y3, x2 + mSize130.cx, y3 + mSize130.cy);
        rect2.UnionRect(rect2, rect1);
        mCategories[i]->Create(mWndClass, "", WS_CHILD, rect1, this, i + 1200);

        y++;
        if (y >= 3) {
            y = 0;
            x++;
        }
    }
    y = 3;

    y2 += (mSize130.cy - 1) * y;
    x2 = 3;
    rect1.SetRect(x2, y2, x2 + mSize138.cx, y2 + mSize138.cy);
    rect2.UnionRect(rect2, rect1);
    mCategoryScroll->Create(mWndClass, "", WS_VISIBLE | WS_CHILD, rect1, this, 1300);

    y = m140;
    y2 += mSize138.cy + 6;
    rect1.SetRect(x2, y2, x2 + mSize130.cx * 3 - 2, y2 + y + 2);
    rect2.UnionRect(rect2, rect1);
    mToolTitle->Create(mWndClass, "", WS_VISIBLE | WS_CHILD, rect1, this, 1400);

    y2 += y + 2;
    m14C[kToolHelpMode2] = y2;

    x = 0;
    y = 0;

    for (i = 0; i < kNumTool; i++) {
        x2 = (mSize130.cx - 1) * x + 3;
        y3 = y2 + (mSize130.cy - 1) * y;
        rect1.SetRect(x2, y3, x2 + mSize130.cx, y3 + mSize130.cy);
        rect2.UnionRect(rect2, rect1);
        mTools[i]->Create(mWndClass, "", WS_CHILD, rect1, this, i + 1500);

        y++;
        if (y >= 4) {
            y = 0;
            x++;
        }
    }
    y = 4;

    y2 += (mSize130.cy - 1) * y;
    x2 = 3;
    rect1.SetRect(x2, y2, x2 + mSize138.cx, y2 + mSize138.cy);
    rect2.UnionRect(rect2, rect1);
    mToolScroll->Create(mWndClass, "", WS_VISIBLE | WS_CHILD, rect1, this, 1600);

    CRect windowRect;
    GetWindowRect(windowRect);

    CRect clientRect;
    GetClientRect(clientRect);

    SetWindowPos(
        NULL,
        0,
        0,
        rect2.Width() + (windowRect.Width() - clientRect.Width()) + 6,
        rect2.Height() + (windowRect.Height() - clientRect.Height()) + 11,
        SWP_NOMOVE | SWP_NOZORDER
        );

    m124 = true;
    ListUpdated();
    Updated();

    return 0;
}

/*virtual*/ BOOL ToolPalette::OnEraseBkgndProc(CDC *pDC) {
    int saved = pDC->SaveDC();
    pDC->SelectPalette(mWorldDef->GetPalette(), false);
    pDC->RealizePalette();

    CBrush backBrush;
    backBrush.CreateStockObject(LTGRAY_BRUSH);

    CRect rect1;
    GetClientRect(rect1);
    pDC->FillRect(rect1, &backBrush);

    CPen pen1;
    pen1.CreatePen(PS_SOLID, 0, PALETTEINDEX(T2PaletteAnimeDef::GetCommonColor(0)));

    CPen pen2;
    pen2.CreatePen(PS_SOLID, 0, PALETTEINDEX(T2PaletteAnimeDef::GetCommonColor(3)));

    CRect rect2, rect3;
    GetClientRect(rect2);

    pDC->SelectObject(pen1);
    pDC->MoveTo(rect2.right - 1, rect2.top);
    pDC->LineTo(rect2.left, rect2.top);
    pDC->LineTo(rect2.left, rect2.bottom);

    pDC->SelectObject(pen2);
    pDC->MoveTo(rect2.right - 1, rect2.top + 1);
    pDC->LineTo(rect2.right - 1, rect2.bottom - 1);
    pDC->LineTo(rect2.left, rect2.bottom - 1);

    mCategoryTitle->GetWindowRect(rect2);
    ScreenToClient(rect2);

    mCategoryScroll->GetWindowRect(rect3);
    ScreenToClient(rect3);

    pDC->SelectObject(pen2);
    pDC->MoveTo(rect3.right, rect2.top - 1);
    pDC->LineTo(rect2.left - 1, rect2.top - 1);
    pDC->LineTo(rect2.left - 1, rect3.bottom + 1);

    pDC->SelectObject(pen1);
    pDC->MoveTo(rect3.right, rect2.top);
    pDC->LineTo(rect3.right, rect3.bottom);
    pDC->LineTo(rect3.left - 1, rect3.bottom);

    mToolTitle->GetWindowRect(rect2);
    ScreenToClient(rect2);

    mToolScroll->GetWindowRect(rect3);
    ScreenToClient(rect3);

    pDC->SelectObject(pen2);
    pDC->MoveTo(rect3.right, rect2.top - 1);
    pDC->LineTo(rect2.left - 1, rect2.top - 1);
    pDC->LineTo(rect2.left - 1, rect3.bottom + 1);

    pDC->SelectObject(pen1);
    pDC->MoveTo(rect3.right, rect2.top);
    pDC->LineTo(rect3.right, rect3.bottom);
    pDC->LineTo(rect3.left - 1, rect3.bottom);

    pDC->RestoreDC(saved);
    return true;
}

/*virtual*/ void ToolPalette::OnSizeProc(UINT nType, int cx, int cy) {
}

/*virtual*/ void ToolPalette::Updated() {
    if (!m124)
        return;

    T2ToolDef *thePlugin;
    T2ToolIconItem *icon;
    int theCategoryNo;
    POSITION pos;

    int theOption = GetIconOption(mSel);
    BYTE isChange = 0;

    switch (theOption) {
        case kToolOption1:
        case kToolOption2:
        case kToolOption3:
            thePlugin = (T2ToolDef *) GetIconPlugin(mSel);
#line 596
            _ASSERT(thePlugin != NULL);

            theCategoryNo = thePlugin->mCategoryNo;
            pos = mToolIconList->GetHeadPosition();
            while (pos) {
                icon = mToolIconList->GetNext(pos);
                switch (icon->mOption) {
                    case kToolOption4:
                        if (icon->mValiation == theCategoryNo) {
                            if (!icon->m24) {
                                icon->m24 = true;
                                isChange |= 1;
                            }
                        } else {
                            if (icon->m24) {
                                icon->m24 = false;
                                isChange |= 1;
                            }
                        }
                        break;

                    case kToolOption1:
                    case kToolOption2:
                    case kToolOption3:
                        if (icon->mID == mSel) {
                            ToolHistoryItem *history = GetToolHistory(((T2ToolDef *) GetIconPlugin(mSel))->mCategoryNo);
                            if (history->_C == -1) {
                                history->_C = mSel;
                                history->_8 = 0;
                            }
                            if (!icon->m24) {
                                icon->m24 = true;
                                isChange |= 2;
                            }

                            mCategoryTitle->SetText(thePlugin->mCategoryName);
                            mToolTitle->SetText(*thePlugin->mToolName[icon->mValiation]);
                        } else {
                            if (icon->m24) {
                                icon->m24 = false;
                                isChange |= 2;
                            }
                        }
                        break;

                    case kToolOption0:
                        if (icon->m24) {
                            icon->m24 = false;
                            isChange |= 4;
                        }
                        break;
                }
            }

            if (isChange & 1) {
                for (int i = 0; i < kNumCategory; i++)
                    mCategories[i]->InvalidateRect(NULL);
                ChangeCategory(theCategoryNo);
            }
            if (isChange & 2) {
                for (int i = 0; i < kNumTool; i++)
                    mTools[i]->InvalidateRect(NULL);
            }
            if (isChange & 4) {
                for (int i = 0; i < kNumCommand; i++)
                    mCommands[i]->InvalidateRect(NULL);
            }

            mDocument->SetCursorType(kCursorDefault, false);
            break;

        case kToolOption0:
            pos = mToolIconList->GetHeadPosition();
            while (pos) {
                icon = mToolIconList->GetNext(pos);
                switch (icon->mOption) {
                    case kToolOption1:
                    case kToolOption2:
                    case kToolOption3:
                        if (icon->m24) {
                            icon->m24 = false;
                            isChange |= 1;
                        }
                        break;

                    case kToolOption4:
                        if (icon->m24) {
                            icon->m24 = false;
                            isChange |= 2;
                        }
                        break;

                    case kToolOption0:
                        if (icon->mID == mSel) {
                            if (!icon->m24) {
                                icon->m24 = true;
                                isChange |= 4;
                            }
                        } else {
                            if (icon->m24) {
                                icon->m24 = false;
                                isChange |= 4;
                            }
                        }
                        break;
                }
            }

            if (isChange & 1) {
                for (int i = 0; i < kNumCategory; i++)
                    mCategories[i]->InvalidateRect(NULL);
                ChangeCategory();
            }
            if (isChange & 2) {
                for (int i = 0; i < kNumTool; i++)
                    mTools[i]->InvalidateRect(NULL);
            }

            if (isChange && 4) {
                for (int i = 0; i < kNumCommand; i++)
                    mCommands[i]->InvalidateRect(NULL);
            }
            if (isChange) {
                mCategoryTitle->SetText("");
                mToolTitle->SetText("");
            }

            mDocument->SetCursorType(mSel, false);
            break;
    }

    if (isChange) {
        mCategoryTitle->InvalidateRect(NULL);
        mToolTitle->InvalidateRect(NULL);
    }
}

/*virtual*/ void ToolPalette::ListUpdated() {
    if (!m124)
        return;

    UpdateCommand();
    UpdateCategory();
    UpdateTool();
}

void ToolPalette::UpdateScroll(ToolPaletteItem *inItem) {
    if (inItem == mCategoryScroll)
        UpdateCategory();

    if (inItem == mToolScroll) {
        UpdateTool();
        if (_184 != -1) {
            ToolHistoryItem *history = GetToolHistory(((T2ToolDef *) GetIconPlugin(_184))->mCategoryNo);
            history->_8 = mToolScroll->GetScrollPos();
        }
    }
}

static const char *commandNames[] = {
    "ToolDestruct",
    "ToolFinger",
    "ToolInfo",
    "ToolZoom",
    "ToolHand",
    "ToolMic",
    "ToolRoot"
};

void ToolPalette::UpdateCommand() {
    BOOL valid = true;
    int i;

    for (i = 0; i < kNumCommand; i++) {
        if (GetID(commandNames[i], 0) == -1) {
            valid = false;
            break;
        }
    }

    if (valid) {
        for (i = 0; i < kNumCommand; i++)
            mCommands[i]->SetIcon(GetItem(commandNames[i], 0));
    }
}

void ToolPalette::UpdateCategory() {
    int baseIndex = mCategoryScroll->GetScrollPos() * m144;
    int currIndex = 0;
    int numIcons = 0;
    CList<T2ToolIconItem *, T2ToolIconItem *> iconList;

    POSITION pos = mToolIconList->GetHeadPosition();
    while (pos) {
        T2ToolIconItem *icon = mToolIconList->GetNext(pos);
        if (icon->mOption == kToolOption4) {
            BOOL added = false;
            if (icon->mToolDef) {
                POSITION pos2 = iconList.GetHeadPosition();
                while (pos2) {
                    POSITION prevPos2 = pos2;
                    T2ToolIconItem *icon2 = iconList.GetNext(pos2);
                    if (icon2->mToolDef && icon2->mToolDef->GetSortKey() > icon->mToolDef->GetSortKey()) {
                        iconList.InsertBefore(prevPos2, icon);
                        added = true;
                        break;
                    }
                }
            }

            if (!added)
                iconList.AddTail(icon);
        }
    }

    pos = iconList.GetHeadPosition();
    while (pos) {
        T2ToolIconItem *icon = iconList.GetNext(pos);
        if (currIndex >= baseIndex && numIcons < kNumCategory) {
            mCategories[numIcons]->SetIcon(icon);
            mCategories[numIcons]->ShowWindow(SW_SHOW);
            numIcons++;
        }
        currIndex++;
    }

    for (; numIcons < kNumCategory; numIcons++)
        mCategories[numIcons]->ShowWindow(SW_HIDE);

    currIndex = ((currIndex + m144 - 1) / m144) - 3;
    if (currIndex < 0)
        currIndex = 0;
    mCategoryScroll->SetScrollRange(currIndex);
}

void ToolPalette::UpdateTool() {
    T2ToolIconItem *icon;
    POSITION pos = mToolIconList->GetHeadPosition();

    while (pos) {
        icon = mToolIconList->GetNext(pos);
        if (icon->mOption == kToolOption4 && icon->m24) {
            ChangeCategory(icon->mValiation);
            break;
        }
    }
}

void ToolPalette::ChangeCategory(int inCategory) {
    if (!m124)
        return;

    int baseIndex = mToolScroll->GetScrollPos() * m148;
    int currIndex = 0;
    int numIcons = 0;
    CList<T2ToolIconItem *, T2ToolIconItem *> iconList;

    POSITION pos = mToolIconList->GetHeadPosition();
    while (pos) {
        T2ToolIconItem *icon = mToolIconList->GetNext(pos);
        if (icon->mOption == kToolOption1 || icon->mOption == kToolOption2 || icon->mOption == kToolOption3) {
            if (((T2ToolDef *) icon->mPlugin)->mCategoryNo == inCategory) {
                BOOL added = false;
                if (icon->mToolDef) {
                    POSITION pos2 = iconList.GetHeadPosition();
                    while (pos2) {
                        POSITION prevPos2 = pos2;
                        T2ToolIconItem *icon2 = iconList.GetNext(pos2);
                        if (icon2->mToolDef && icon2->mToolDef->GetSortKey() > icon->mToolDef->GetSortKey()) {
                            iconList.InsertBefore(prevPos2, icon);
                            added = true;
                            break;
                        }
                    }
                }

                if (!added)
                    iconList.AddTail(icon);
            }
        }
    }

    pos = iconList.GetHeadPosition();
    while (pos) {
        T2ToolIconItem *icon = iconList.GetNext(pos);
        if (currIndex >= baseIndex && numIcons < kNumTool) {
            mTools[numIcons]->SetIcon(icon);
            mTools[numIcons]->ShowWindow(SW_SHOW);
            numIcons++;
        }
        currIndex++;
    }

    for (; numIcons < kNumTool; numIcons++)
        mTools[numIcons]->ShowWindow(SW_HIDE);

    currIndex = ((currIndex + m148 - 1) / m148) - 3;
    if (currIndex < 0)
        currIndex = 0;
    mToolScroll->SetScrollRange(currIndex);
}

void ToolPalette::ChangeCategory() {
    if (!m124)
        return;

    for (int i = 0; i < kNumTool; i++)
        mTools[i]->ShowWindow(SW_HIDE);
    mToolScroll->SetScrollRange(0);
}

/*virtual*/ void ToolPalette::RedrawButton() {
    if (!m124)
        return;

    int i;
    for (i = 0; i < kNumCategory; i++)
        mCategories[i]->InvalidateRect(NULL);
    for (i = 0; i < kNumTool; i++)
        mTools[i]->InvalidateRect(NULL);
    for (i = 0; i < kNumCommand; i++)
        mCommands[i]->InvalidateRect(NULL);
}

void ToolPalette::ShowHelpWindow() {
    HideHelpWindow();

    int mode;
    switch (mClickedItem->mOption) {
        case kToolOption0:
            mode = kToolHelpMode0;
            break;
        case kToolOption4:
            mode = kToolHelpMode1;
            break;
        default:
            mode = kToolHelpMode2;
            break;
    }

    RECT rect;
    GetWindowRect(&rect);

    mToolHelpPt.y = GetSystemMetrics(SM_CYSMSIZE);
    mToolHelpPt.y += rect.top;
    mToolHelpPt.x = rect.right + 8;
    mToolHelpPt.y += m14C[mode];

    CString text;
    mToolHelpValiation = mClickedItem->mValiation;
    mToolHelpMode = mode;

    switch (mode) {
        case kToolHelpMode0:
            mToolHelpStr2 = mClickedItem->m2C;
            break;
        case kToolHelpMode1:
            mToolHelpStr1 = m15C->mCategoryName;
            mToolHelpStr2 = m15C->mCategoryCommentString;
            break;
        case kToolHelpMode2:
            mToolHelpDef = m15C;
            break;
    }

    mToolHelpWnd = new T2ToolHelpWnd;
    StartTimer(500);
}

void ToolPalette::HideHelpWindow() {
    if (mToolHelpWnd) {
        mToolHelpWnd->CloseToolHelp();
        mToolHelpWnd = NULL;
    }
    StopTimer();
}

/*virtual*/ void ToolPalette::OnTimerProc(UINT nIDEvent) {
    mToolHelpWnd->OpenToolHelp(mToolHelpPt, mToolHelpMode, mToolHelpStr1, mToolHelpStr2, mToolHelpDef, mToolHelpValiation);
    StopTimer();
}

ToolHistoryItem *ToolPalette::GetToolHistory(int inID) {
    ToolHistoryItem *history;
    POSITION pos = mHistoryList.GetHeadPosition();
    while (pos) {
        history = mHistoryList.GetNext(pos);
        if (history->_4 == inID)
            return history;
    }

    history = new ToolHistoryItem;
    history->_4 = inID;
    mHistoryList.AddTail(history);
    return history;
}


ToolHistoryItem::ToolHistoryItem() {
    _4 = -1;
    _8 = 0;
    _C = -1;
}

/*virtual*/ ToolHistoryItem::~ToolHistoryItem() {
}



ToolHistoryList::ToolHistoryList() {
}

/*virtual*/ ToolHistoryList::~ToolHistoryList() {
}