////////////////////////////////////////////////////////////////////////////////
//
//      File: GIFView.cpp
//
//      Date: December 1999
//
//      Author: Daniel Switkin
//
//      Copyright 2003 (c) by Daniel Switkin. This file is made publically available
//      under the BSD license, with the stipulations that this complete header must
//      remain at the top of the file indefinitely, and credit must be given to the
//      original author in any about box using this software.
//
////////////////////////////////////////////////////////////////////////////////

// Additional authors:  Stephan Aßmus, <superstippi@gmx.de>
//                                              Philippe Saint-Pierre, <stpere@gmail.com>
//                                              Maxime Simon, <maxime.simon@gmail.com>
//                                              John Scipione, <jscipione@gmail.com>

#include "GIFView.h"

#include <stdio.h>
#include <stdlib.h>

#include <Box.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <LayoutBuilder.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <RadioButton.h>
#include <SpaceLayoutItem.h>
#include <StringView.h>
#include <String.h>
#include <TextControl.h>

#include "GIFTranslator.h"
#include "SavePalette.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "GIFView"


GIFView::GIFView(TranslatorSettings* settings)
        :
        BGroupView("GIFView", B_VERTICAL),
        fSettings(settings)
{
        SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

        fTitle = new BStringView("Title", B_TRANSLATE("GIF image translator"));
        fTitle->SetFont(be_bold_font);

        char version_string[100];
        snprintf(version_string, sizeof(version_string),
                B_TRANSLATE("Version %d.%d.%d, %s"),
                int(B_TRANSLATION_MAJOR_VERSION(GIF_TRANSLATOR_VERSION)),
                int(B_TRANSLATION_MINOR_VERSION(GIF_TRANSLATOR_VERSION)),
                int(B_TRANSLATION_REVISION_VERSION(GIF_TRANSLATOR_VERSION)),
                __DATE__);
        fVersion = new BStringView("Version", version_string);

        const char* copyrightString
                = "©2003 Daniel Switkin, software@switkin.com";
        fCopyright = new BStringView("Copyright", copyrightString);

        // menu fields (Palette & Colors)
        fWebSafeMI = new BMenuItem(B_TRANSLATE("Websafe"),
                new BMessage(GV_WEB_SAFE), 0, 0);
        fBeOSSystemMI = new BMenuItem(B_TRANSLATE("BeOS system"),
                new BMessage(GV_BEOS_SYSTEM), 0, 0);
        fGreyScaleMI = new BMenuItem(B_TRANSLATE("Greyscale"),
                new BMessage(GV_GREYSCALE), 0, 0);
        fOptimalMI = new BMenuItem(B_TRANSLATE("Optimal"),
                new BMessage(GV_OPTIMAL), 0, 0);
        fPaletteM = new BPopUpMenu("PalettePopUpMenu", true, true,
                B_ITEMS_IN_COLUMN);
        fPaletteM->AddItem(fWebSafeMI);
        fPaletteM->AddItem(fBeOSSystemMI);
        fPaletteM->AddItem(fGreyScaleMI);
        fPaletteM->AddItem(fOptimalMI);

        fColorCountM = new BPopUpMenu("ColorCountPopUpMenu", true, true,
                B_ITEMS_IN_COLUMN);
        int32 count = 2;
        for (int32 i = 0; i < 8; i++) {
                BMessage* message = new BMessage(GV_SET_COLOR_COUNT);
                message->AddInt32(GIF_SETTING_PALETTE_SIZE, i + 1);
                BString label;
                label << count;
                fColorCountMI[i] = new BMenuItem(label.String(), message, 0, 0);
                fColorCountM->AddItem(fColorCountMI[i]);
                count *= 2;
        }
        fColorCount256MI = fColorCountMI[7];

        fPaletteMF = new BMenuField(B_TRANSLATE("Palette:"), fPaletteM);
        fPaletteMF->SetAlignment(B_ALIGN_RIGHT);
        fColorCountMF = new BMenuField(B_TRANSLATE("Colors:"), fColorCountM);
        fColorCountMF->SetAlignment(B_ALIGN_RIGHT);

        // check boxes
        fUseDitheringCB = new BCheckBox(B_TRANSLATE("Use dithering"),
                new BMessage(GV_USE_DITHERING));
        fDitheringBox = new BBox("dithering", B_WILL_DRAW, B_NO_BORDER);
        fDitheringBox->SetLabel(fUseDitheringCB);

        fInterlacedCB = new BCheckBox(B_TRANSLATE("Write interlaced images"),
                new BMessage(GV_INTERLACED));
        fInterlacedBox = new BBox("interlaced", B_WILL_DRAW, B_NO_BORDER);
        fInterlacedBox->SetLabel(fInterlacedCB);

        fUseTransparentCB = new BCheckBox(B_TRANSLATE("Write transparent images"),
                new BMessage(GV_USE_TRANSPARENT));

        // radio buttons
        fUseTransparentAutoRB = new BRadioButton(
                B_TRANSLATE("Automatic (from alpha channel)"),
                new BMessage(GV_USE_TRANSPARENT_AUTO));

        fUseTransparentColorRB = new BRadioButton(B_TRANSLATE("Use RGB color"),
                new BMessage(GV_USE_TRANSPARENT_COLOR));

        // text controls
        fRedTextControl = new BTextControl("", "0",
                new BMessage(GV_TRANSPARENT_RED));
        fGreenTextControl = new BTextControl("", "0",
                new BMessage(GV_TRANSPARENT_GREEN));
        fBlueTextControl = new BTextControl("", "0",
                new BMessage(GV_TRANSPARENT_BLUE));

        fTransparentBox = new BBox(B_FANCY_BORDER,
                BLayoutBuilder::Grid<>(3.0f, 5.0f)
                        .Add(fUseTransparentAutoRB, 0, 0, 4, 1)
                        .Add(fUseTransparentColorRB, 0, 1)
                        .Add(fRedTextControl, 1, 1)
                        .Add(fGreenTextControl, 2, 1)
                        .Add(fBlueTextControl, 3, 1)
                        .SetInsets(10.0f, 6.0f, 10.0f, 10.0f)
                        .View());
        fTransparentBox->SetLabel(fUseTransparentCB);

        BTextView* redTextView = fRedTextControl->TextView();
        BTextView* greenTextView = fGreenTextControl->TextView();
        BTextView* bluetextView = fBlueTextControl->TextView();

        for (uint32 x = 0; x < 256; x++) {
                if (x < '0' || x > '9') {
                        redTextView->DisallowChar(x);
                        greenTextView->DisallowChar(x);
                        bluetextView->DisallowChar(x);
                }
        }

        BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
                .SetInsets(B_USE_DEFAULT_SPACING)
                .Add(fTitle)
                .Add(fVersion)
                .Add(fCopyright)
                .AddGlue()
                .AddGrid(10.0f, 5.0f)
                        .Add(fPaletteMF->CreateLabelLayoutItem(), 0, 0)
                        .AddGroup(B_HORIZONTAL, 0.0f, 1, 0)
                                .Add(fPaletteMF->CreateMenuBarLayoutItem(), 0.0f)
                                .AddGlue()
                                .End()
                        .Add(fColorCountMF->CreateLabelLayoutItem(), 0, 1)
                        .AddGroup(B_HORIZONTAL, 0.0f, 1, 1)
                                .Add(fColorCountMF->CreateMenuBarLayoutItem(), 0.0f)
                                .AddGlue()
                                .End()
                        .End()
                .AddStrut(B_USE_SMALL_SPACING)
                .Add(fDitheringBox)
                .Add(fInterlacedBox)
                .Add(fTransparentBox)
                .AddGlue()
                .End();

        fSettings->Acquire();

        RestorePrefs();
}


GIFView::~GIFView()
{
        fSettings->Release();

        delete fTitle;
        delete fVersion;
        delete fCopyright;
        delete fPaletteMF;
        delete fColorCountMF;
        delete fDitheringBox;
        delete fInterlacedBox;
        delete fTransparentBox;
}


void
GIFView::RestorePrefs()
{
        fColorCountMF->SetEnabled(false);
        fUseDitheringCB->SetEnabled(true);

        switch (fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE)) {
                case WEB_SAFE_PALETTE:
                        fWebSafeMI->SetMarked(true);
                        break;

                case BEOS_SYSTEM_PALETTE:
                        fBeOSSystemMI->SetMarked(true);
                        break;

                case GREYSCALE_PALETTE:
                        fGreyScaleMI->SetMarked(true);
                        fUseDitheringCB->SetEnabled(false);
                        break;

                case OPTIMAL_PALETTE:
                        fOptimalMI->SetMarked(true);
                        fColorCountMF->SetEnabled(true);
                        break;

                default:
                {
                        int32 value = WEB_SAFE_PALETTE;
                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE, &value);
                        fSettings->SaveSettings();
                        fWebSafeMI->SetMarked(true);
                }
        }

        if (fColorCountMF->IsEnabled()
                && fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE) > 0
                && fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE) <= 8) {
                // display the stored color count
                fColorCountMI[fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE) - 1]
                        ->SetMarked(true);
        } else {
                // display 256 colors
                fColorCount256MI->SetMarked(true);
                int32 value = 8;
                fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE, &value);
                fSettings->SaveSettings();
        }

        fInterlacedCB->SetValue(fSettings->SetGetBool(GIF_SETTING_INTERLACED));

        if (fGreyScaleMI->IsMarked())
                fUseDitheringCB->SetValue(false);
        else {
                fUseDitheringCB->SetValue(
                        fSettings->SetGetBool(GIF_SETTING_USE_DITHERING));
        }
        fUseTransparentCB->SetValue(
                fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT));
        fUseTransparentAutoRB->SetValue(
                fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO));
        fUseTransparentColorRB->SetValue(
                !fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO));
        if (fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT)) {
                fUseTransparentAutoRB->SetEnabled(true);
                fUseTransparentColorRB->SetEnabled(true);
                fRedTextControl->SetEnabled(
                        !fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO));
                fGreenTextControl->SetEnabled(
                        !fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO));
                fBlueTextControl->SetEnabled(
                        !fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO));
        } else {
                fUseTransparentAutoRB->SetEnabled(false);
                fUseTransparentColorRB->SetEnabled(false);
                fRedTextControl->SetEnabled(false);
                fGreenTextControl->SetEnabled(false);
                fBlueTextControl->SetEnabled(false);
        }

        char temp[4];
        sprintf(temp, "%d",
                (int)fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_RED));
        fRedTextControl->SetText(temp);
        sprintf(temp, "%d",
                (int)fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_GREEN));
        fGreenTextControl->SetText(temp);
        sprintf(temp, "%d",
                (int)fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_BLUE));
        fBlueTextControl->SetText(temp);
}


void
GIFView::AllAttached()
{
        BMessenger messenger(this);
        fInterlacedCB->SetTarget(messenger);
        fUseDitheringCB->SetTarget(messenger);
        fUseTransparentCB->SetTarget(messenger);
        fUseTransparentAutoRB->SetTarget(messenger);
        fUseTransparentColorRB->SetTarget(messenger);
        fRedTextControl->SetTarget(messenger);
        fGreenTextControl->SetTarget(messenger);
        fBlueTextControl->SetTarget(messenger);
        fPaletteM->SetTargetForItems(messenger);
        fColorCountM->SetTargetForItems(messenger);

        BView::AllAttached();

        if (Parent() == NULL && Window()->GetLayout() == NULL) {
                Window()->SetLayout(new BGroupLayout(B_VERTICAL));
                Window()->ResizeTo(PreferredSize().Width(), PreferredSize().Height());
        }
}


void
GIFView::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case GV_WEB_SAFE:
                {
                        int32 value = WEB_SAFE_PALETTE;
                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE, &value);
                        fUseDitheringCB->SetEnabled(true);
                        fColorCountMF->SetEnabled(false);
                        fColorCount256MI->SetMarked(true);
                        break;
                }

                case GV_BEOS_SYSTEM:
                {
                        int32 value = BEOS_SYSTEM_PALETTE;
                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE, &value);
                        fUseDitheringCB->SetEnabled(true);
                        fColorCountMF->SetEnabled(false);
                        fColorCount256MI->SetMarked(true);
                        break;
                }

                case GV_GREYSCALE:
                {
                        int32 value = GREYSCALE_PALETTE;
                        bool usedithering = false;
                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE, &value);
                        fSettings->SetGetBool(GIF_SETTING_USE_DITHERING, &usedithering);
                        fUseDitheringCB->SetEnabled(false);
                        fUseDitheringCB->SetValue(false);
                        fColorCountMF->SetEnabled(false);
                        fColorCount256MI->SetMarked(true);
                        break;
                }

                case GV_OPTIMAL:
                {
                        int32 value = OPTIMAL_PALETTE;
                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_MODE, &value);
                        fUseDitheringCB->SetEnabled(true);
                        fColorCountMF->SetEnabled(true);
                        fColorCountMI[fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE) - 1]
                                ->SetMarked(true);
                        break;
                }

                case GV_SET_COLOR_COUNT:
                        if (fColorCountMF->IsEnabled()) {
                                int32 sizeInBits;
                                if (message->FindInt32(GIF_SETTING_PALETTE_SIZE, &sizeInBits)
                                                >= B_OK && sizeInBits > 0 && sizeInBits <= 8) {
                                        fSettings->SetGetInt32(GIF_SETTING_PALETTE_SIZE,
                                                &sizeInBits);
                                }
                        }
                        break;

                case GV_INTERLACED:
                {
                        bool value = fInterlacedCB->Value();
                        fSettings->SetGetBool(GIF_SETTING_INTERLACED, &value);
                        break;
                }

                case GV_USE_DITHERING:
                {
                        bool value = fUseDitheringCB->Value();
                        fSettings->SetGetBool(GIF_SETTING_USE_DITHERING, &value);
                        break;
                }

                case GV_USE_TRANSPARENT:
                {
                        bool value = fUseTransparentCB->Value();
                        fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT, &value);
                        if (value) {
                                fUseTransparentAutoRB->SetEnabled(true);
                                fUseTransparentColorRB->SetEnabled(true);
                                fRedTextControl->SetEnabled(fUseTransparentColorRB->Value());
                                fGreenTextControl->SetEnabled(fUseTransparentColorRB->Value());
                                fBlueTextControl->SetEnabled(fUseTransparentColorRB->Value());
                        } else {
                                fUseTransparentAutoRB->SetEnabled(false);
                                fUseTransparentColorRB->SetEnabled(false);
                                fRedTextControl->SetEnabled(false);
                                fGreenTextControl->SetEnabled(false);
                                fBlueTextControl->SetEnabled(false);
                        }
                        break;
                }

                case GV_USE_TRANSPARENT_AUTO:
                {
                        bool value = true;
                        fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO, &value);
                        fRedTextControl->SetEnabled(false);
                        fGreenTextControl->SetEnabled(false);
                        fBlueTextControl->SetEnabled(false);
                        break;
                }

                case GV_USE_TRANSPARENT_COLOR:
                {
                        bool value = false;
                        fSettings->SetGetBool(GIF_SETTING_USE_TRANSPARENT_AUTO, &value);
                        fRedTextControl->SetEnabled(true);
                        fGreenTextControl->SetEnabled(true);
                        fBlueTextControl->SetEnabled(true);
                        break;
                }

                case GV_TRANSPARENT_RED:
                {
                        int32 value = CheckInput(fRedTextControl);
                        fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_RED, &value);
                        break;
                }

                case GV_TRANSPARENT_GREEN:
                {
                        int32 value = CheckInput(fGreenTextControl);
                        fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_GREEN, &value);
                        break;
                }

                case GV_TRANSPARENT_BLUE:
                {
                        int32 value = CheckInput(fBlueTextControl);
                        fSettings->SetGetInt32(GIF_SETTING_TRANSPARENT_BLUE, &value);
                        break;
                }

                default:
                        BView::MessageReceived(message);
        }

        fSettings->SaveSettings();
}


int
GIFView::CheckInput(BTextControl* control)
{
        int value = atoi(control->Text());
        if (value < 0 || value > 255) {
                value = (value < 0) ? 0 : 255;
                char temp[4];
                sprintf(temp, "%d", value);
                control->SetText(temp);
        }

        return value;
}