path: root/ldmicro/lutdialog.cpp

//-----------------------------------------------------------------------------
// Copyright 2007 Jonathan Westhues
//
// This file is part of LDmicro.
// 
// LDmicro 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 3 of the License, or
// (at your option) any later version.
// 
// LDmicro 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 LDmicro.  If not, see <http://www.gnu.org/licenses/>.
//------
//
// Dialog for entering the elements of a look-up table. I allow two formats:
// as a simple list of integer values, or like a string. The lookup table
// can either be a straight LUT, or one with piecewise linear interpolation
// in between the points.
// Jonathan Westhues, Dec 2005
//-----------------------------------------------------------------------------
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <commctrl.h>

#include "ldmicro.h"

static HWND LutDialog;

static HWND AsStringCheckbox;
static HWND CountTextbox;
static HWND DestTextbox;
static HWND IndexTextbox;
static HWND Labels[3];

static HWND StringTextbox;

static BOOL WasAsString;
static int WasCount;

static HWND ValuesTextbox[MAX_LOOK_UP_TABLE_LEN];
static LONG_PTR PrevValuesProc[MAX_LOOK_UP_TABLE_LEN];
static HWND ValuesLabel[MAX_LOOK_UP_TABLE_LEN];

static SWORD ValuesCache[MAX_LOOK_UP_TABLE_LEN];

static LONG_PTR PrevDestProc;
static LONG_PTR PrevIndexProc;
static LONG_PTR PrevCountProc;

//-----------------------------------------------------------------------------
// Don't allow any characters other than 0-9 and minus in the values.
//-----------------------------------------------------------------------------
static LRESULT CALLBACK MyNumberProc(HWND hwnd, UINT msg, WPARAM wParam,
    LPARAM lParam)
{
    if(msg == WM_CHAR) {
        if(!(isdigit(wParam) || wParam == '\b' || wParam == '-')) {
            return 0;
        }
    }
    
    WNDPROC w;
    int i;
    for(i = 0; i < MAX_LOOK_UP_TABLE_LEN; i++) {
        if(hwnd == ValuesTextbox[i]) {
            w = (WNDPROC)PrevValuesProc[i];
            break;
        }
    }
    if(i == MAX_LOOK_UP_TABLE_LEN) oops();

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

//-----------------------------------------------------------------------------
// Don't allow any characters other than 0-9 in the count.
//-----------------------------------------------------------------------------
static LRESULT CALLBACK MyDigitsProc(HWND hwnd, UINT msg, WPARAM wParam,
    LPARAM lParam)
{
    if(msg == WM_CHAR) {
        if(!(isdigit(wParam) || wParam == '\b')) {
            return 0;
        }
    }

    return CallWindowProc((WNDPROC)PrevCountProc, hwnd, msg, wParam, lParam);
}

//-----------------------------------------------------------------------------
// Don't allow any characters other than A-Za-z0-9_ in the name.
//-----------------------------------------------------------------------------
static LRESULT CALLBACK MyNameProc(HWND hwnd, UINT msg, WPARAM wParam,
    LPARAM lParam)
{
    if(msg == WM_CHAR) {
        if(!(isalpha(wParam) || isdigit(wParam) || wParam == '_' ||
            wParam == '\b'))
        {
            return 0;
        }
    }

    WNDPROC w;
    if(hwnd == DestTextbox) {
        w = (WNDPROC)PrevDestProc;
    } else if(hwnd == IndexTextbox) {
        w = (WNDPROC)PrevIndexProc;
    }
    return CallWindowProc(w, hwnd, msg, wParam, lParam);
}

//-----------------------------------------------------------------------------
// Make the controls that are guaranteed not to move around as the count/
// as string settings change. This is different for the piecewise linear,
// because in that case we should not provide a checkbox to change whether
// the table is edited as a string or table.
//-----------------------------------------------------------------------------
static void MakeFixedControls(BOOL forPwl)
{
    Labels[0] = CreateWindowEx(0, WC_STATIC, _("Destination:"),
        WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,
        0, 10, 78, 21, LutDialog, NULL, Instance, NULL);
    NiceFont(Labels[0]);

    DestTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",
        WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,
        85, 10, 120, 21, LutDialog, NULL, Instance, NULL);
    FixedFont(DestTextbox);

    Labels[1] = CreateWindowEx(0, WC_STATIC, _("Index:"),
        WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,
        10, 40, 68, 21, LutDialog, NULL, Instance, NULL);
    NiceFont(Labels[1]);

    IndexTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",
        WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,
        85, 40, 120, 21, LutDialog, NULL, Instance, NULL);
    FixedFont(IndexTextbox);

    Labels[2] = CreateWindowEx(0,WC_STATIC, forPwl ? _("Points:") : _("Count:"),
        WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT,
        0, 70, 78, 21, LutDialog, NULL, Instance, NULL);
    NiceFont(Labels[2]);

    CountTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",
        WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,
        85, 70, 120, 21, LutDialog, NULL, Instance, NULL);
    NiceFont(CountTextbox);

    if(!forPwl) {
        AsStringCheckbox = CreateWindowEx(0, WC_BUTTON, 
            _("Edit table of ASCII values like a string"), WS_CHILD |
                WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_AUTOCHECKBOX,
            10, 100, 300, 21, LutDialog, NULL, Instance, NULL);
        NiceFont(AsStringCheckbox);
    }

    OkButton = CreateWindowEx(0, WC_BUTTON, _("OK"),
        WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE | BS_DEFPUSHBUTTON,
        231, 10, 70, 23, LutDialog, NULL, Instance, NULL); 
    NiceFont(OkButton);

    CancelButton = CreateWindowEx(0, WC_BUTTON, _("Cancel"),
        WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | WS_VISIBLE,
        231, 40, 70, 23, LutDialog, NULL, Instance, NULL); 
    NiceFont(CancelButton);

    PrevDestProc = SetWindowLongPtr(DestTextbox, GWLP_WNDPROC, 
        (LONG_PTR)MyNameProc);
    PrevIndexProc = SetWindowLongPtr(IndexTextbox, GWLP_WNDPROC, 
        (LONG_PTR)MyNameProc);
    PrevCountProc = SetWindowLongPtr(CountTextbox, GWLP_WNDPROC, 
        (LONG_PTR)MyDigitsProc);
}

//-----------------------------------------------------------------------------
// Destroy all of the controls so that we can start anew. This is necessary
// because if the size of the LUT changes, or if the user switches from 
// table entry to string entry, we must completely reconfigure the dialog.
//-----------------------------------------------------------------------------
static void DestroyLutControls(void)
{
    if(WasAsString) {
        // Nothing to do; we constantly update the cache from the user-
        // specified string, because we might as well do that when we
        // calculate the length.
    } else {
        int i;
        for(i = 0; i < WasCount; i++) {
            char buf[20];
            SendMessage(ValuesTextbox[i], WM_GETTEXT, (WPARAM)16, (LPARAM)buf);
            ValuesCache[i] = atoi(buf);
        }
    }

    DestroyWindow(StringTextbox);

    int i;
    for(i = 0; i < MAX_LOOK_UP_TABLE_LEN; i++) {
        DestroyWindow(ValuesTextbox[i]);
        DestroyWindow(ValuesLabel[i]);
    }
}

//-----------------------------------------------------------------------------
// Make the controls that hold the LUT. The exact configuration of the dialog
// will depend on (a) whether the user chose table-type or string-type entry,
// and for table-type entry, on (b) the number of entries, and on (c)
// whether we are editing a PWL table (list of points) or a straight LUT.
//-----------------------------------------------------------------------------
static void MakeLutControls(BOOL asString, int count, BOOL forPwl)
{
    // Remember these, so that we know from where to cache stuff if we have
    // to destroy these textboxes and make something new later.
    WasAsString = asString;
    WasCount = count;

    if(forPwl && asString) oops();

    if(asString) {
        char str[3*MAX_LOOK_UP_TABLE_LEN+1];
        int i, j;
        j = 0;
        for(i = 0; i < count; i++) {
            int c = ValuesCache[i];
            if(c >= 32 && c <= 127 && c != '\\') {
                str[j++] = c;
            } else if(c == '\\') {
                str[j++] = '\\';
                str[j++] = '\\';
            } else if(c == '\r') {
                str[j++] = '\\';
                str[j++] = 'r';
            } else if(c == '\b') {
                str[j++] = '\\';
                str[j++] = 'b';
            } else if(c == '\f') {
                str[j++] = '\\';
                str[j++] = 'f';
            } else if(c == '\n') {
                str[j++] = '\\';
                str[j++] = 'n';
            } else {
                str[j++] = 'X';
            }
        }
        str[j++] = '\0';
        StringTextbox = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, str,
            WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS | 
                WS_VISIBLE,
            10, 130, 294, 21, LutDialog, NULL, Instance, NULL);
        FixedFont(StringTextbox);
        SendMessage(CountTextbox, EM_SETREADONLY, (WPARAM)TRUE, 0);
        MoveWindow(LutDialog, 100, 30, 320, 185, TRUE);
    } else {
        int i;
        int base;
        if(forPwl) {
            base = 100;
        } else {
            base = 140;
        }
        for(i = 0; i < count; i++) {
            int x, y;

            if(i < 16) {
                x = 10;
                y = base+30*i;
            } else {
                x = 160;
                y = base+30*(i-16);
            }

            char buf[20];
            sprintf(buf, "%d", ValuesCache[i]);
            ValuesTextbox[i] = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, buf,
                WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS |
                    WS_VISIBLE,
                x+30, y, 80, 21, LutDialog, NULL, Instance, NULL);
            NiceFont(ValuesTextbox[i]);

            if(forPwl) {
                sprintf(buf, "%c%d:", (i & 1) ? 'y' : 'x', i/2);
            } else {
                sprintf(buf, "%2d:", i);
            }
            ValuesLabel[i] = CreateWindowEx(0, WC_STATIC, buf,
                WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,
                x, y+3, 100, 21, LutDialog, NULL, Instance, NULL);
            FixedFont(ValuesLabel[i]);

            PrevValuesProc[i] = SetWindowLongPtr(ValuesTextbox[i],
                GWLP_WNDPROC, (LONG_PTR)MyNumberProc);
        }
        if(count > 16) count = 16;
        SendMessage(CountTextbox, EM_SETREADONLY, (WPARAM)FALSE, 0);

        MoveWindow(LutDialog, 100, 30, 320, base + 30 + count*30, TRUE);
    }
}

//-----------------------------------------------------------------------------
// Decode a string into a look-up table; store the values in ValuesCache[],
// and update the count checkbox (which in string mode is read-only) to
// reflect the new length. Returns FALSE if the new string is too long, else
// TRUE.
//-----------------------------------------------------------------------------
BOOL StringToValuesCache(char *str, int *c)
{
    int count = 0;
    while(*str) {
        if(*str == '\\') {
            str++;
            switch(*str) {
                case 'r': ValuesCache[count++] = '\r'; break;
                case 'n': ValuesCache[count++] = '\n'; break;
                case 'f': ValuesCache[count++] = '\f'; break;
                case 'b': ValuesCache[count++] = '\b'; break;
                default:  ValuesCache[count++] = *str; break;
            }
        } else {
            ValuesCache[count++] = *str;
        }
        if(*str) {
            str++;
        }
        if(count >= 32) {
            return FALSE;
        }
    }

    char buf[10];
    sprintf(buf, "%d", count);
    SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)(buf));
    *c = count;
    return TRUE;
}

//-----------------------------------------------------------------------------
// Show the look-up table dialog. This one is nasty, mostly because there are
// two ways to enter a look-up table: as a table, or as a string. Presumably
// I should convert between those two representations on the fly, as the user
// edit things, so I do.
//-----------------------------------------------------------------------------
void ShowLookUpTableDialog(ElemLeaf *l)
{
    ElemLookUpTable *t = &(l->d.lookUpTable);

    // First copy over all the stuff from the leaf structure; in particular,
    // we need our own local copy of the table entries, because it would be
    // bad to update those in the leaf before the user clicks okay (as he
    // might cancel).
    int count = t->count;
    BOOL asString = t->editAsString;
    memset(ValuesCache, 0, sizeof(ValuesCache));
    int i;
    for(i = 0; i < count; i++) {
        ValuesCache[i] = t->vals[i];
    }

    // Now create the dialog's fixed controls, plus the changing (depending
    // on show style/entry count) controls for the initial configuration.
    LutDialog = CreateWindowClient(0, "LDmicroDialog",
        _("Look-Up Table"), WS_OVERLAPPED | WS_SYSMENU,
        100, 100, 320, 375, NULL, NULL, Instance, NULL);
    MakeFixedControls(FALSE);
    MakeLutControls(asString, count, FALSE);
  
    // Set up the controls to reflect the initial configuration.
    SendMessage(DestTextbox, WM_SETTEXT, 0, (LPARAM)(t->dest));
    SendMessage(IndexTextbox, WM_SETTEXT, 0, (LPARAM)(t->index));
    char buf[30];
    sprintf(buf, "%d", t->count);
    SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)buf);
    if(asString) {
        SendMessage(AsStringCheckbox, BM_SETCHECK, BST_CHECKED, 0);
    }

    // And show the window
    EnableWindow(MainWindow, FALSE);
    ShowWindow(LutDialog, TRUE);
    SetFocus(DestTextbox);
    SendMessage(DestTextbox, EM_SETSEL, 0, -1);

    char PrevTableAsString[1024] = "";

    MSG msg;
    DWORD ret;
    DialogDone = FALSE;
    DialogCancel = FALSE;
    while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
        if(msg.message == WM_KEYDOWN) {
            if(msg.wParam == VK_RETURN) {
                DialogDone = TRUE;
                break;
            } else if(msg.wParam == VK_ESCAPE) {
                DialogDone = TRUE;
                DialogCancel = TRUE;
                break;
            }
        }

        if(!IsDialogMessage(LutDialog, &msg)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        // Are we in table mode? In that case watch the (user-editable) count
        // field, and use that to determine how many textboxes to show.
        char buf[20];
        SendMessage(CountTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)buf);
        if(atoi(buf) != count && !asString) {
            count = atoi(buf);
            if(count < 0 || count > 32) {
                count = 0;
                SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)"");
            }
            DestroyLutControls();
            MakeLutControls(asString, count, FALSE);
        }

        // Are we in string mode? In that case watch the string textbox,
        // and use that to update the (read-only) count field.
        if(asString) {
            char scratch[1024];
            SendMessage(StringTextbox, WM_GETTEXT, (WPARAM)sizeof(scratch),
                (LPARAM)scratch);
            if(strcmp(scratch, PrevTableAsString)!=0) {
                if(StringToValuesCache(scratch, &count)) {
                    strcpy(PrevTableAsString, scratch);
                } else {
                    // Too long; put back the old one
                    SendMessage(StringTextbox, WM_SETTEXT, 0,
                        (LPARAM)PrevTableAsString);
                }
            }
        }

        // Did we just change modes?
        BOOL x = SendMessage(AsStringCheckbox, BM_GETCHECK, 0, 0)==BST_CHECKED;
        if((x && !asString) || (!x && asString)) {
            asString = x;
            DestroyLutControls();
            MakeLutControls(asString, count, FALSE);
        }

    }

    if(!DialogCancel) {
        SendMessage(DestTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->dest));
        SendMessage(IndexTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->index));
        DestroyLutControls();
        // The call to DestroyLutControls updated ValuesCache, so just read
        // them out of there (whichever mode we were in before).
        int i;
        for(i = 0; i < count; i++) {
            t->vals[i] = ValuesCache[i];
        }
        t->count = count;
        t->editAsString = asString;
    }

    EnableWindow(MainWindow, TRUE);
    DestroyWindow(LutDialog);
}

//-----------------------------------------------------------------------------
// Show the piecewise linear table dialog. This one can only be edited in
// only a single format, which makes things easier than before.
//-----------------------------------------------------------------------------
void ShowPiecewiseLinearDialog(ElemLeaf *l)
{
    ElemPiecewiseLinear *t = &(l->d.piecewiseLinear);

    // First copy over all the stuff from the leaf structure; in particular,
    // we need our own local copy of the table entries, because it would be
    // bad to update those in the leaf before the user clicks okay (as he
    // might cancel).
    int count = t->count;
    memset(ValuesCache, 0, sizeof(ValuesCache));
    int i;
    for(i = 0; i < count*2; i++) {
        ValuesCache[i] = t->vals[i];
    }

    // Now create the dialog's fixed controls, plus the changing (depending
    // on show style/entry count) controls for the initial configuration.
    LutDialog = CreateWindowClient(0, "LDmicroDialog",
        _("Piecewise Linear Table"), WS_OVERLAPPED | WS_SYSMENU,
        100, 100, 320, 375, NULL, NULL, Instance, NULL);
    MakeFixedControls(TRUE);
    MakeLutControls(FALSE, count*2, TRUE);
  
    // Set up the controls to reflect the initial configuration.
    SendMessage(DestTextbox, WM_SETTEXT, 0, (LPARAM)(t->dest));
    SendMessage(IndexTextbox, WM_SETTEXT, 0, (LPARAM)(t->index));
    char buf[30];
    sprintf(buf, "%d", t->count);
    SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)buf);

    // And show the window
    EnableWindow(MainWindow, FALSE);
    ShowWindow(LutDialog, TRUE);
    SetFocus(DestTextbox);
    SendMessage(DestTextbox, EM_SETSEL, 0, -1);

    MSG msg;
    DWORD ret;
    DialogDone = FALSE;
    DialogCancel = FALSE;
    while((ret = GetMessage(&msg, NULL, 0, 0)) && !DialogDone) {
        if(msg.message == WM_KEYDOWN) {
            if(msg.wParam == VK_RETURN) {
                DialogDone = TRUE;
                break;
            } else if(msg.wParam == VK_ESCAPE) {
                DialogDone = TRUE;
                DialogCancel = TRUE;
                break;
            }
        }

        if(!IsDialogMessage(LutDialog, &msg)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        // Watch the (user-editable) count field, and use that to
        // determine how many textboxes to show.
        char buf[20];
        SendMessage(CountTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)buf);
        if(atoi(buf) != count) {
            count = atoi(buf);
            if(count < 0 || count > 10) {
                count = 0;
                SendMessage(CountTextbox, WM_SETTEXT, 0, (LPARAM)"");
            }
            DestroyLutControls();
            MakeLutControls(FALSE, count*2, TRUE);
        }
    }

    if(!DialogCancel) {
        SendMessage(DestTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->dest));
        SendMessage(IndexTextbox, WM_GETTEXT, (WPARAM)16, (LPARAM)(t->index));
        DestroyLutControls();
        // The call to DestroyLutControls updated ValuesCache, so just read
        // them out of there.
        int i;
        for(i = 0; i < count*2; i++) {
            t->vals[i] = ValuesCache[i];
        }
        t->count = count;
    }

    EnableWindow(MainWindow, TRUE);
    DestroyWindow(LutDialog);
}