#include "solvespace.h"

#define clamp01(x) (max(0, min(1, (x))))

const Style::Default Style::Defaults[] = {
    { ACTIVE_GRP,   "ActiveGrp",    RGBf(1.0, 1.0, 1.0), 1.5, },
    { CONSTRUCTION, "Construction", RGBf(0.1, 0.7, 0.1), 1.5, },
    { INACTIVE_GRP, "InactiveGrp",  RGBf(0.5, 0.3, 0.0), 1.5, },
    { DATUM,        "Datum",        RGBf(0.0, 0.8, 0.0), 1.5, },
    { SOLID_EDGE,   "SolidEdge",    RGBf(0.8, 0.8, 0.8), 1.0, },
    { CONSTRAINT,   "Constraint",   RGBf(1.0, 0.1, 1.0), 1.0, },
    { SELECTED,     "Selected",     RGBf(1.0, 0.0, 0.0), 1.5, },
    { HOVERED,      "Hovered",      RGBf(1.0, 1.0, 0.0), 1.5, },
    { CONTOUR_FILL, "ContourFill",  RGBf(0.0, 0.1, 0.1), 1.0, },
    { NORMALS,      "Normals",      RGBf(0.0, 0.4, 0.4), 1.0, },
    { ANALYZE,      "Analyze",      RGBf(0.0, 1.0, 1.0), 1.0, },
    { DRAW_ERROR,   "DrawError",    RGBf(1.0, 0.0, 0.0), 8.0, },
    { DIM_SOLID,    "DimSolid",     RGBf(0.1, 0.1, 0.1), 1.0, },
    { 0,            NULL,           0,                   0.0, },
};

char *Style::CnfColor(char *prefix) {
    static char name[100];
    sprintf(name, "Style_%s_Color", prefix);
    return name;
}
char *Style::CnfWidth(char *prefix) {
    static char name[100];
    sprintf(name, "Style_%s_Width", prefix);
    return name;
}

char *Style::CnfPrefixToName(char *prefix) {
    static char name[100];
    int i = 0, j;
    strcpy(name, "#def-");
    j = 5;
    while(prefix[i] && j < 90) {
        if(isupper(prefix[i]) && i != 0) {
            name[j++] = '-';
        }
        name[j++] = tolower(prefix[i]);
        i++;
    }
    name[j++] = '\0';
    return name;
}

void Style::CreateAllDefaultStyles(void) {
    const Default *d;
    for(d = &(Defaults[0]); d->h.v; d++) {
        (void)Get(d->h);
    }
}

void Style::CreateDefaultStyle(hStyle h) {
    bool isDefaultStyle = true;
    const Default *d;
    for(d = &(Defaults[0]); d->h.v; d++) {
        if(d->h.v == h.v) break;
    }
    if(!d->h.v) {
        // Not a default style; so just create it the same as our default
        // active group entity style.
        d = &(Defaults[0]);
        isDefaultStyle = false;
    }

    Style ns;
    ZERO(&ns);
    ns.color        = CnfThawDWORD(d->color, CnfColor(d->cnfPrefix));
    ns.width        = CnfThawFloat((float)(d->width), CnfWidth(d->cnfPrefix));
    ns.widthAs      = UNITS_AS_PIXELS;
    ns.textHeight   = DEFAULT_TEXT_HEIGHT;
    ns.textHeightAs = UNITS_AS_PIXELS;
    ns.visible      = true;
    ns.exportable   = true;
    ns.h            = h;
    if(isDefaultStyle) {
        ns.name.strcpy(CnfPrefixToName(d->cnfPrefix));
    } else {
        ns.name.strcpy("new-custom-style");
    }

    SK.style.Add(&ns);
}

void Style::LoadFactoryDefaults(void) {
    const Default *d;
    for(d = &(Defaults[0]); d->h.v; d++) {
        Style *s = Get(d->h);

        s->color        = d->color;
        s->width        = d->width;
        s->widthAs      = UNITS_AS_PIXELS;
        s->textHeight   = DEFAULT_TEXT_HEIGHT;
        s->textHeightAs = UNITS_AS_PIXELS;
        s->visible      = true;
        s->exportable   = true;
        s->name.strcpy(CnfPrefixToName(d->cnfPrefix));
    }
    SS.backgroundColor = RGB(0, 0, 0);
}

void Style::FreezeDefaultStyles(void) {
    const Default *d;
    for(d = &(Defaults[0]); d->h.v; d++) {
        CnfFreezeDWORD(Color(d->h), CnfColor(d->cnfPrefix));
        CnfFreezeFloat((float)Width(d->h), CnfWidth(d->cnfPrefix));
    }
}

DWORD Style::CreateCustomStyle(void) {
    SS.UndoRemember();
    DWORD vs = max(Style::FIRST_CUSTOM, SK.style.MaximumId() + 1);
    hStyle hs = { vs };
    (void)Style::Get(hs);
    return hs.v;
}

void Style::AssignSelectionToStyle(DWORD v) {
    bool showError = false;
    SS.GW.GroupSelection();

    SS.UndoRemember();
    int i;
    for(i = 0; i < SS.GW.gs.entities; i++) {
        hEntity he = SS.GW.gs.entity[i];
        if(!he.isFromRequest()) {
            showError = true;
            continue;
        }

        hRequest hr = he.request();
        Request *r = SK.GetRequest(hr);
        r->style.v = v;
        SS.later.generateAll = true;
    }
    for(i = 0; i < SS.GW.gs.constraints; i++) {
        hConstraint hc = SS.GW.gs.constraint[i];
        Constraint *c = SK.GetConstraint(hc);
        if(c->type != Constraint::COMMENT) continue;

        c->disp.style.v = v;
    }

    if(showError) {
        Error("Can't assign style to an entity that's derived from another "
              "entity; try assigning a style to this entity's parent.");
    }

    SS.GW.ClearSelection();
    InvalidateGraphics();

    // And show that style's info screen in the text window.
    SS.TW.GoToScreen(TextWindow::SCREEN_STYLE_INFO);
    SS.TW.shown.style.v = v;
    SS.later.showTW = true;
}

//-----------------------------------------------------------------------------
// Look up a style by its handle. If that style does not exist, then create
// the style, according to our table of default styles.
//-----------------------------------------------------------------------------
Style *Style::Get(hStyle h) {
    if(h.v == 0) h.v = ACTIVE_GRP;

    Style *s = SK.style.FindByIdNoOops(h);
    if(s) {
        // It exists, good.
        return s;
    } else {
        // It doesn't exist; so we should create it and then return that.
        CreateDefaultStyle(h);
        return SK.style.FindById(h);
    }
}

//-----------------------------------------------------------------------------
// A couple of wrappers, so that I can call these functions with either an
// hStyle or with the integer corresponding to that hStyle.v.
//-----------------------------------------------------------------------------
DWORD Style::Color(int s, bool forExport) {
    hStyle hs = { s };
    return Color(hs, forExport);
}
float Style::Width(int s) {
    hStyle hs = { s };
    return Width(hs);
}

//-----------------------------------------------------------------------------
// Return the color associated with our style as 8-bit RGB.
//-----------------------------------------------------------------------------
DWORD Style::Color(hStyle h, bool forExport) {
    Style *s = Get(h);
    if(forExport) {
        Vector rgb = Vector::From(REDf(s->color),
                                  GREENf(s->color),
                                  BLUEf(s->color));
        rgb = rgb.Minus(Vector::From(1, 1, 1));
        if(rgb.Magnitude() < 0.4 && SS.fixExportColors) {
            // This is an almost-white color in a default style, which is
            // good for the default on-screen view (black bg) but probably
            // not desired in the exported files, which typically are shown
            // against white backgrounds.
            return RGB(0, 0, 0);
        }
    }
    return s->color;
}

//-----------------------------------------------------------------------------
// Return the width associated with our style in pixels..
//-----------------------------------------------------------------------------
float Style::Width(hStyle h) {
    double r = 1.0;
    Style *s = Get(h);
    if(s->widthAs == UNITS_AS_MM) {
        r = s->width * SS.GW.scale;
    } else if(s->widthAs == UNITS_AS_PIXELS) {
        r = s->width;
    }
    // This returns a float because glLineWidth expects a float, avoid casts.
    return (float)r;
}

//-----------------------------------------------------------------------------
// Return the width associated with our style in millimeters..
//-----------------------------------------------------------------------------
double Style::WidthMm(int hs) {
    double widthpx = Width(hs);
    return widthpx / SS.GW.scale;
}

//-----------------------------------------------------------------------------
// Return the associated text height, in pixels.
//-----------------------------------------------------------------------------
double Style::TextHeight(hStyle hs) {
    Style *s = Get(hs);
    if(s->textHeightAs == UNITS_AS_MM) {
        return s->textHeight * SS.GW.scale;
    } else if(s->textHeightAs == UNITS_AS_PIXELS) {
        return s->textHeight;
    } else {
        return DEFAULT_TEXT_HEIGHT;
    }
}

//-----------------------------------------------------------------------------
// Should lines and curves from this style appear in the output file? Only
// if it's both shown and exportable.
//-----------------------------------------------------------------------------
bool Style::Exportable(int si) {
    hStyle hs = { si };
    Style *s = Get(hs);
    return (s->exportable) && (s->visible);
}

//-----------------------------------------------------------------------------
// Return the appropriate style for our entity. If the entity has a style
// explicitly assigned, then it's that style. Otherwise it's the appropriate
// default style.
//-----------------------------------------------------------------------------
hStyle Style::ForEntity(hEntity he) {
    Entity *e = SK.GetEntity(he);
    // If the entity has a special style, use that. If that style doesn't
    // exist yet, then it will get created automatically later.
    if(e->style.v != 0) {
        return e->style;
    }

    // Otherwise, we use the default rules.
    hStyle hs;
    if(e->group.v != SS.GW.activeGroup.v) {
        hs.v = INACTIVE_GRP;
    } else if(e->construction) {
        hs.v = CONSTRUCTION;
    } else {
        hs.v = ACTIVE_GRP;
    }
    return hs;
}

char *Style::DescriptionString(void) {
    static char ret[100];
    if(name.str[0]) {
        sprintf(ret, "s%03x-%s", h.v, name.str);
    } else {
        sprintf(ret, "s%03x-(unnamed)", h.v);
    }
    return ret;
}


void TextWindow::ScreenShowListOfStyles(int link, DWORD v) {
    SS.TW.GoToScreen(SCREEN_LIST_OF_STYLES);
}
void TextWindow::ScreenShowStyleInfo(int link, DWORD v) {
    SS.TW.GoToScreen(SCREEN_STYLE_INFO);
    SS.TW.shown.style.v = v;
}

void TextWindow::ScreenLoadFactoryDefaultStyles(int link, DWORD v) {
    Style::LoadFactoryDefaults();
    SS.TW.GoToScreen(SCREEN_LIST_OF_STYLES);
}

void TextWindow::ScreenCreateCustomStyle(int link, DWORD v) {
    Style::CreateCustomStyle();
}

void TextWindow::ScreenChangeBackgroundColor(int link, DWORD v) {
    DWORD rgb = SS.backgroundColor;
    char str[300];
    sprintf(str, "%.2f, %.2f, %.2f", REDf(rgb), GREENf(rgb), BLUEf(rgb));
    ShowTextEditControl(v, 3, str);
    SS.TW.edit.meaning = EDIT_BACKGROUND_COLOR;
}

void TextWindow::ShowListOfStyles(void) {
    Printf(true, "%Ft color  style-name");

    bool darkbg = false;
    Style *s;
    for(s = SK.style.First(); s; s = SK.style.NextAfter(s)) {
        Printf(false, "%Bp  %Bp   %Bp   %Fl%Ll%f%D%s%E",
            darkbg ? 'd' : 'a',
            0x80000000 | s->color,
            darkbg ? 'd' : 'a',
            ScreenShowStyleInfo, s->h.v,
            s->DescriptionString());

        darkbg = !darkbg;
    }

    Printf(true, "  %Fl%Ll%fcreate a new custom style%E", 
        &ScreenCreateCustomStyle);

    Printf(false, "");

    DWORD rgb = SS.backgroundColor;
    Printf(false, "%Ft background color (r, g, b)%E");
    Printf(false, "%Ba   %@, %@, %@ %Fl%D%f%Ll[change]%E",
        REDf(rgb), GREENf(rgb), BLUEf(rgb),
        top[rows-1] + 2, &ScreenChangeBackgroundColor);

    Printf(false, "");
    Printf(false, "  %Fl%Ll%fload factory defaults%E",
        &ScreenLoadFactoryDefaultStyles);
}


void TextWindow::ScreenChangeStyleName(int link, DWORD v) {
    hStyle hs = { v };
    Style *s = Style::Get(hs);
    ShowTextEditControl(10, 13, s->name.str);
    SS.TW.edit.style = hs;
    SS.TW.edit.meaning = EDIT_STYLE_NAME;   
}

void TextWindow::ScreenDeleteStyle(int link, DWORD v) {
    SS.UndoRemember();
    hStyle hs = { v };
    Style *s = SK.style.FindByIdNoOops(hs);
    if(s) {
        SK.style.RemoveById(hs);
        // And it will get recreated automatically if something is still using
        // the style, so no need to do anything else.
    }
    SS.TW.GoToScreen(SCREEN_LIST_OF_STYLES);
    InvalidateGraphics();
}

void TextWindow::ScreenChangeStyleWidthOrTextHeight(int link, DWORD v) {
    hStyle hs = { v };
    Style *s = Style::Get(hs);
    double val   = (link == 'w') ? s->width   : s->textHeight;
    int    units = (link == 'w') ? s->widthAs : s->textHeightAs;

    char str[300];
    if(units == Style::UNITS_AS_PIXELS) {
        sprintf(str, "%.2f", val);
    } else {
        strcpy(str, SS.MmToString(val));
    }
    ShowTextEditControl((link == 'w') ? 21 : 26, 13, str);
    SS.TW.edit.style = hs;
    SS.TW.edit.meaning = (link == 'w') ? EDIT_STYLE_WIDTH :
                                         EDIT_STYLE_TEXT_HEIGHT;
}

void TextWindow::ScreenChangeStyleColor(int link, DWORD v) {
    hStyle hs = { v };
    Style *s = Style::Get(hs);
    char str[300];
    sprintf(str, "%.2f, %.2f, %.2f",
        REDf(s->color), GREENf(s->color), BLUEf(s->color));
    ShowTextEditControl(13, 12, str);
    SS.TW.edit.style = hs;
    SS.TW.edit.meaning = EDIT_STYLE_COLOR;
}

void TextWindow::ScreenChangeStyleYesNo(int link, DWORD v) {
    SS.UndoRemember();
    hStyle hs = { v };
    Style *s = Style::Get(hs);
    switch(link) {
        case 'w':
            // Units for the width
            if(s->widthAs == Style::UNITS_AS_PIXELS) {
                s->widthAs = Style::UNITS_AS_MM;
                s->width /= SS.GW.scale;
            } else {
                s->widthAs = Style::UNITS_AS_PIXELS;
                s->width *= SS.GW.scale;
            }
            break;

        case 'h':
            // Units for the height
            if(s->textHeightAs == Style::UNITS_AS_PIXELS) {
                s->textHeightAs = Style::UNITS_AS_MM;
                s->textHeight /= SS.GW.scale;
            } else {
                s->textHeightAs = Style::UNITS_AS_PIXELS;
                s->textHeight *= SS.GW.scale;
            }
            break;

        case 'e':
            s->exportable = !(s->exportable);
            break;

        case 'v':
            s->visible = !(s->visible);
            break;

        // Horizontal text alignment
        case 'L':
            s->textOrigin |=  Style::ORIGIN_LEFT;
            s->textOrigin &= ~Style::ORIGIN_RIGHT;
            break;
        case 'H':
            s->textOrigin &= ~Style::ORIGIN_LEFT;
            s->textOrigin &= ~Style::ORIGIN_RIGHT;
            break;
        case 'R':
            s->textOrigin &= ~Style::ORIGIN_LEFT;
            s->textOrigin |=  Style::ORIGIN_RIGHT;
            break;

        // Vertical text alignment
        case 'B':
            s->textOrigin |=  Style::ORIGIN_BOT;
            s->textOrigin &= ~Style::ORIGIN_TOP;
            break;
        case 'V':
            s->textOrigin &= ~Style::ORIGIN_BOT;
            s->textOrigin &= ~Style::ORIGIN_TOP;
            break;
        case 'T':
            s->textOrigin &= ~Style::ORIGIN_BOT;
            s->textOrigin |=  Style::ORIGIN_TOP;
            break;
    }
    InvalidateGraphics();
}

bool TextWindow::EditControlDoneForStyles(char *str) {
    Style *s;
    switch(edit.meaning) {
        case EDIT_STYLE_TEXT_HEIGHT:
        case EDIT_STYLE_WIDTH: {
            SS.UndoRemember();
            s = Style::Get(edit.style);

            double v;
            int units = (edit.meaning == EDIT_STYLE_TEXT_HEIGHT) ?
                            s->textHeightAs : s->widthAs;
            if(units == Style::UNITS_AS_MM) {
                v = SS.StringToMm(str);
            } else {
                v = atof(str);
            }
            v = max(0, v);
            if(edit.meaning == EDIT_STYLE_TEXT_HEIGHT) {
                s->textHeight = v;
            } else {
                s->width = v;
            }
            return true;
        }
        case EDIT_BACKGROUND_COLOR:
        case EDIT_STYLE_COLOR: {
            double r, g, b;
            if(sscanf(str, "%lf, %lf, %lf", &r, &g, &b)==3) {
                r = clamp01(r);
                g = clamp01(g);
                b = clamp01(b);
                if(edit.meaning == EDIT_STYLE_COLOR) {
                    SS.UndoRemember();
                    s = Style::Get(edit.style);
                    s->color = RGBf(r, g, b);
                } else {
                    SS.backgroundColor = RGBf(r, g, b);
                }
            } else {
                Error("Bad format: specify color as r, g, b");
            }
            return true;
        }
        case EDIT_STYLE_NAME:
            if(!StringAllPrintable(str) || !*str) {
                Error("Invalid characters. Allowed are: A-Z a-z 0-9 _ -");
            } else {
                SS.UndoRemember();
                s = Style::Get(edit.style);
                s->name.strcpy(str);
            }
            return true;

        default: return false;
    }
}

void TextWindow::ShowStyleInfo(void) {
    Printf(true, "%Fl%f%Ll(back to list of styles)%E", &ScreenShowListOfStyles);

    Style *s = Style::Get(shown.style);

    if(s->h.v < Style::FIRST_CUSTOM) {
        Printf(true, "%FtSTYLE   %E%s ", s->DescriptionString());
    } else {
        Printf(true, "%FtSTYLE   %E%s "
                     "[%Fl%Ll%D%frename%E/%Fl%Ll%D%fdel%E]",
            s->DescriptionString(),
            s->h.v, &ScreenChangeStyleName,
            s->h.v, &ScreenDeleteStyle);
    }

    Printf(true, "%FtCOLOR   %E%Bp  %Bd (%@, %@, %@) %D%f%Ll%Fl[change]%E",
        0x80000000 | s->color,
        REDf(s->color), GREENf(s->color), BLUEf(s->color),
        s->h.v, ScreenChangeStyleColor);

    if(s->h.v >= Style::FIRST_CUSTOM) {
        Printf(true, "%FtSHOW    %Fh%D%f%Lv%s%E%Fs%s%E / %Fh%D%f%Lv%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ( s->visible ? "" : "yes"),
            ( s->visible ? "yes" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (!s->visible ? "" : "no"),
            (!s->visible ? "no" : ""));
        Printf(false,"%FtEXPORT  %Fh%D%f%Le%s%E%Fs%s%E / %Fh%D%f%Le%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ( s->exportable ? "" : "yes"),
            ( s->exportable ? "yes" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (!s->exportable ? "" : "no"),
            (!s->exportable ? "no" : ""));
    }

    char *unit = (SS.viewUnits == SolveSpace::UNIT_INCHES) ? "inches" : "mm";

    // The line width, and its units
    if(s->widthAs == Style::UNITS_AS_PIXELS) {
        Printf(true, "%FtLINE WIDTH   %E%@ %D%f%Lw%Fl[change]%E",
            s->width,
            s->h.v, &ScreenChangeStyleWidthOrTextHeight);
    } else {
        Printf(true, "%FtLINE WIDTH   %E%s %D%f%Lw%Fl[change]%E",
            SS.MmToString(s->width),
            s->h.v, &ScreenChangeStyleWidthOrTextHeight);
    }

    bool widthpx = (s->widthAs == Style::UNITS_AS_PIXELS);
    if(s->h.v < Style::FIRST_CUSTOM) {
        Printf(false,"%FtIN UNITS OF  %Fspixels%E");
    } else {
        Printf(false,"%FtIN UNITS OF  "
                            "%Fh%D%f%Lw%s%E%Fs%s%E / %Fh%D%f%Lw%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ( widthpx ? "" : "pixels"),
            ( widthpx ? "pixels" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (!widthpx ? "" : unit),
            (!widthpx ? unit : ""));
    }

    // The text height, and its units
    char *chng = (s->h.v < Style::FIRST_CUSTOM) ? "" : "[change]";
    if(s->textHeightAs == Style::UNITS_AS_PIXELS) {
        Printf(true, "%FtTEXT HEIGHT  %E%@ %D%f%Lt%Fl%s%E",
            s->textHeight,
            s->h.v, &ScreenChangeStyleWidthOrTextHeight,
            chng);
    } else {
        Printf(true, "%FtTEXT HEIGHT  %E%s %D%f%Lt%Fl%s%E",
            SS.MmToString(s->textHeight),
            s->h.v, &ScreenChangeStyleWidthOrTextHeight,
            chng);
    }

    bool textHeightpx = (s->textHeightAs == Style::UNITS_AS_PIXELS);
    if(s->h.v < Style::FIRST_CUSTOM) {
        Printf(false,"%FtIN UNITS OF  %Fspixels%E");
    } else {
        Printf(false,"%FtIN UNITS OF  "
                            "%Fh%D%f%Lh%s%E%Fs%s%E / %Fh%D%f%Lh%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ( textHeightpx ? "" : "pixels"),
            ( textHeightpx ? "pixels" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (!textHeightpx ? "" : unit),
            (!textHeightpx ? unit : ""));
    }

    if(s->h.v >= Style::FIRST_CUSTOM) {
        bool neither;

        neither = !(s->textOrigin & (Style::ORIGIN_LEFT | Style::ORIGIN_RIGHT));
        Printf(true, "%FtALIGN TEXT   "
                            "%Fh%D%f%LL%s%E%Fs%s%E   / "
                            "%Fh%D%f%LH%s%E%Fs%s%E / "
                            "%Fh%D%f%LR%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ((s->textOrigin & Style::ORIGIN_LEFT) ? "" : "left"),
            ((s->textOrigin & Style::ORIGIN_LEFT) ? "left" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (neither ? "" : "center"),
            (neither ? "center" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            ((s->textOrigin & Style::ORIGIN_RIGHT) ? "" : "right"),
            ((s->textOrigin & Style::ORIGIN_RIGHT) ? "right" : ""));

        neither = !(s->textOrigin & (Style::ORIGIN_BOT | Style::ORIGIN_TOP));
        Printf(false, "%Ft             "
                            "%Fh%D%f%LB%s%E%Fs%s%E / "
                            "%Fh%D%f%LV%s%E%Fs%s%E / "
                            "%Fh%D%f%LT%s%E%Fs%s%E",
            s->h.v, &ScreenChangeStyleYesNo,
            ((s->textOrigin & Style::ORIGIN_BOT) ? "" : "bottom"),
            ((s->textOrigin & Style::ORIGIN_BOT) ? "bottom" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            (neither ? "" : "center"),
            (neither ? "center" : ""),
            s->h.v, &ScreenChangeStyleYesNo,
            ((s->textOrigin & Style::ORIGIN_TOP) ? "" : "top"),
            ((s->textOrigin & Style::ORIGIN_TOP) ? "top" : ""));
    }

    if(s->h.v >= Style::FIRST_CUSTOM) {
        Printf(false, "");
        Printf(false, "To assign lines or curves to this style,");
        Printf(false, "select them on the drawing. Then commit");
        Printf(false, "by clicking the link at the bottom of");
        Printf(false, "this window.");
    }
}

void TextWindow::ScreenAssignSelectionToStyle(int link, DWORD v) {
    Style::AssignSelectionToStyle(v);
}