/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include "MainWin.h"
#include "MainApp.h"
#include "Controller.h"
#include "config.h"
#include "DeviceRoster.h"

#include <stdio.h>
#include <string.h>

#include <Application.h>
#include <Alert.h>
#include <Menu.h>
#include <MenuBar.h>
#include <MenuItem.h>
#include <Messenger.h>
#include <PopUpMenu.h>
#include <Screen.h>
#include <String.h>
#include <View.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MainWin"

B_TRANSLATE_MARK_VOID("TV");
B_TRANSLATE_MARK_VOID("unknown");
B_TRANSLATE_MARK_VOID("DVB - Digital Video Broadcasting TV");

enum
{
        M_DUMMY = 0x100,
        M_FILE_QUIT,
        M_SCALE_TO_NATIVE_SIZE,
        M_TOGGLE_FULLSCREEN,
        M_TOGGLE_NO_BORDER,
        M_TOGGLE_NO_MENU,
        M_TOGGLE_NO_BORDER_NO_MENU,
        M_TOGGLE_ALWAYS_ON_TOP,
        M_TOGGLE_KEEP_ASPECT_RATIO,
        M_PREFERENCES,
        M_CHANNEL_NEXT,
        M_CHANNEL_PREV,
        M_VOLUME_UP,
        M_VOLUME_DOWN,
        M_ASPECT_100000_1,
        M_ASPECT_106666_1,
        M_ASPECT_109091_1,
        M_ASPECT_141176_1,
        M_ASPECT_720_576,
        M_ASPECT_704_576,
        M_ASPECT_544_576,
        M_SELECT_INTERFACE              = 0x00000800,
        M_SELECT_INTERFACE_END  = 0x00000fff,
        M_SELECT_CHANNEL                = 0x00010000,
        M_SELECT_CHANNEL_END    = 0x000fffff,
                // this limits possible channel count to 0xeffff = 983039
};

//#define printf(a...)


MainWin::MainWin(BRect frame_rect)
        :
        BWindow(frame_rect, B_TRANSLATE_SYSTEM_NAME(NAME), B_TITLED_WINDOW,
        B_ASYNCHRONOUS_CONTROLS /* | B_WILL_ACCEPT_FIRST_CLICK */)
 ,      fController(new Controller)
 ,      fIsFullscreen(false)
 ,      fKeepAspectRatio(true)
 ,      fAlwaysOnTop(false)
 ,      fNoMenu(false)
 ,      fNoBorder(false)
 ,      fSourceWidth(720)
 ,      fSourceHeight(576)
 ,      fWidthScale(1.0)
 ,      fHeightScale(1.0)
 ,      fMouseDownTracking(false)
 ,      fFrameResizedTriggeredAutomatically(false)
 ,      fIgnoreFrameResized(false)
 ,      fFrameResizedCalled(true)
{
        BRect rect = Bounds();

        // background
        fBackground = new BView(rect, "background", B_FOLLOW_ALL,
                B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE);
        fBackground->SetViewColor(0,0,0);
        AddChild(fBackground);

        // menu
        fMenuBar = new BMenuBar(fBackground->Bounds(), "menu");
        CreateMenu();
        fBackground->AddChild(fMenuBar);
        fMenuBar->ResizeToPreferred();
        fMenuBarHeight = (int)fMenuBar->Frame().Height() + 1;
        fMenuBar->SetResizingMode(B_FOLLOW_TOP | B_FOLLOW_LEFT_RIGHT);

        // video view
        BRect video_rect = BRect(0, fMenuBarHeight, rect.right, rect.bottom);
        fVideoView = new VideoView(video_rect, "video display", B_FOLLOW_ALL,
                B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE);
        fBackground->AddChild(fVideoView);

        fVideoView->MakeFocus();

//      SetSizeLimits(fControlViewMinWidth - 1, 32767,
//              fMenuBarHeight + fControlViewHeight - 1, fMenuBarHeight
//              + fControlViewHeight - 1);

//      SetSizeLimits(320 - 1, 32767, 240 + fMenuBarHeight - 1, 32767);

        SetSizeLimits(0, 32767, fMenuBarHeight - 1, 32767);

        fController->SetVideoView(fVideoView);
        fController->SetVideoNode(fVideoView->Node());

        fVideoView->IsOverlaySupported();

        SetupInterfaceMenu();
        SelectInitialInterface();
        SetInterfaceMenuMarker();
        SetupChannelMenu();
        SetChannelMenuMarker();

        VideoFormatChange(fSourceWidth, fSourceHeight, fWidthScale, fHeightScale);

        CenterOnScreen();
}


MainWin::~MainWin()
{
        printf("MainWin::~MainWin\n");
        fController->DisconnectInterface();
        delete fController;
}


void
MainWin::CreateMenu()
{
        fFileMenu = new BMenu(B_TRANSLATE(NAME));
        fChannelMenu = new BMenu(B_TRANSLATE("Channel"));
        fInterfaceMenu = new BMenu(B_TRANSLATE("Interface"));
        fSettingsMenu = new BMenu(B_TRANSLATE("Settings"));
        fDebugMenu = new BMenu(B_TRANSLATE("Debug"));

        fMenuBar->AddItem(fFileMenu);
        fMenuBar->AddItem(fChannelMenu);
        fMenuBar->AddItem(fInterfaceMenu);
        fMenuBar->AddItem(fSettingsMenu);
        fMenuBar->AddItem(fDebugMenu);

        fFileMenu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
                new BMessage(M_FILE_QUIT), 'Q', B_COMMAND_KEY));

/*
        fChannelMenu->AddItem(new BMenuItem(B_TRANSLATE("Next channel"),
                new BMessage(M_CHANNEL_NEXT), '+', B_COMMAND_KEY));
        fChannelMenu->AddItem(new BMenuItem(B_TRANSLATE("Previous channel"),
                new BMessage(M_CHANNEL_PREV), '-', B_COMMAND_KEY));
        fChannelMenu->AddSeparatorItem();
        fChannelMenu->AddItem(new BMenuItem("RTL", new BMessage(M_DUMMY), '0',
                B_COMMAND_KEY));
        fChannelMenu->AddItem(new BMenuItem("Pro7", new BMessage(M_DUMMY), '1',
                B_COMMAND_KEY));

        fInterfaceMenu->AddItem(new BMenuItem(B_TRANSLATE("none"),
                new BMessage(M_DUMMY)));
        fInterfaceMenu->AddItem(new BMenuItem(B_TRANSLATE("none 1"),
                new BMessage(M_DUMMY)));
        fInterfaceMenu->AddItem(new BMenuItem(B_TRANSLATE("none 2"),
                new BMessage(M_DUMMY)));
*/

        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("Scale to native size"),
                new BMessage(M_SCALE_TO_NATIVE_SIZE), 'N', B_COMMAND_KEY));
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("Full screen"),
                new BMessage(M_TOGGLE_FULLSCREEN), 'F', B_COMMAND_KEY));
        fSettingsMenu->AddSeparatorItem();
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("No menu"),
                new BMessage(M_TOGGLE_NO_MENU), 'M', B_COMMAND_KEY));
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("No border"),
                new BMessage(M_TOGGLE_NO_BORDER), 'B', B_COMMAND_KEY));
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("Always on top"),
                new BMessage(M_TOGGLE_ALWAYS_ON_TOP), 'T', B_COMMAND_KEY));
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("Keep aspect ratio"),
                new BMessage(M_TOGGLE_KEEP_ASPECT_RATIO), 'K', B_COMMAND_KEY));
        fSettingsMenu->AddSeparatorItem();
        fSettingsMenu->AddItem(new BMenuItem(B_TRANSLATE("Settings" B_UTF8_ELLIPSIS)
                , new BMessage(M_PREFERENCES), ',', B_COMMAND_KEY));

        const char* pixel_ratio = B_TRANSLATE("pixel aspect ratio");
        BString str1 = pixel_ratio;
        str1 << " 1.00000:1";
        fDebugMenu->AddItem(new BMenuItem(str1.String(),
                new BMessage(M_ASPECT_100000_1)));
        BString str2 = pixel_ratio;
        str2 << " 1.06666:1";
        fDebugMenu->AddItem(new BMenuItem(str2.String(),
                new BMessage(M_ASPECT_106666_1)));
        BString str3 = pixel_ratio;
        str3 << " 1.09091:1";
        fDebugMenu->AddItem(new BMenuItem(str3.String(),
                new BMessage(M_ASPECT_109091_1)));
        BString str4 = pixel_ratio;
        str4 << " 1.41176:1";
        fDebugMenu->AddItem(new BMenuItem(str4.String(),
                new BMessage(M_ASPECT_141176_1)));
        fDebugMenu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 720 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_720_576)));
        fDebugMenu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 704 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_704_576)));
        fDebugMenu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 544 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_544_576)));

        fSettingsMenu->ItemAt(1)->SetMarked(fIsFullscreen);
        fSettingsMenu->ItemAt(3)->SetMarked(fNoMenu);
        fSettingsMenu->ItemAt(4)->SetMarked(fNoBorder);
        fSettingsMenu->ItemAt(5)->SetMarked(fAlwaysOnTop);
        fSettingsMenu->ItemAt(6)->SetMarked(fKeepAspectRatio);
        fSettingsMenu->ItemAt(8)->SetEnabled(false);
                // XXX disable unused preference menu
}


void
MainWin::SetupInterfaceMenu()
{
        fInterfaceMenu->RemoveItems(0, fInterfaceMenu->CountItems(), true);

        fInterfaceMenu->AddItem(new BMenuItem(B_TRANSLATE("None"),
                new BMessage(M_SELECT_INTERFACE)));

        int count = gDeviceRoster->DeviceCount();

        if (count > 0)
                fInterfaceMenu->AddSeparatorItem();

        for (int i = 0; i < count; i++) {
                // 1 gets subtracted in MessageReceived, so -1 is Interface None,
                // and 0 == Interface 0 in SelectInterface()
                fInterfaceMenu->AddItem(new BMenuItem(gDeviceRoster->DeviceName(i),
                        new BMessage(M_SELECT_INTERFACE + i + 1)));
        }
}


void
MainWin::SetupChannelMenu()
{
        fChannelMenu->RemoveItems(0, fChannelMenu->CountItems(), true);

        int interface = fController->CurrentInterface();
        printf("MainWin::SetupChannelMenu: interface %d\n", interface);

        int channels = fController->ChannelCount();

        if (channels == 0) {
                fChannelMenu->AddItem(new BMenuItem(B_TRANSLATE("None"),
                        new BMessage(M_DUMMY)));
        } else {
                fChannelMenu->AddItem(new BMenuItem(B_TRANSLATE("Next channel"),
                        new BMessage(M_CHANNEL_NEXT), '+', B_COMMAND_KEY));
                fChannelMenu->AddItem(new BMenuItem(B_TRANSLATE("Previous channel"),
                        new BMessage(M_CHANNEL_PREV), '-', B_COMMAND_KEY));
                fChannelMenu->AddSeparatorItem();
        }

        for (int i = 0; i < channels; i++) {
                BString string;
                string.SetToFormat("%s%d %s", (i < 9) ? "  " : "", i + 1,
                        fController->ChannelName(i));
                fChannelMenu->AddItem(new BMenuItem(string,
                        new BMessage(M_SELECT_CHANNEL + i)));
        }
}


void
MainWin::SetInterfaceMenuMarker()
{
        BMenuItem *item;

        int interface = fController->CurrentInterface();
        printf("MainWin::SetInterfaceMenuMarker: interface %d\n", interface);

        // remove old marker
        item = fInterfaceMenu->FindMarked();
        if (item)
                item->SetMarked(false);

        // set new marker
        int index = (interface < 0) ? 0 : interface + 2;
        item = fInterfaceMenu->ItemAt(index);
        if (item)
                item->SetMarked(true);
}


void
MainWin::SetChannelMenuMarker()
{
        BMenuItem *item;

        int channel = fController->CurrentChannel();
        printf("MainWin::SetChannelMenuMarker: channel %d\n", channel);

        // remove old marker
        item = fChannelMenu->FindMarked();
        if (item)
                item->SetMarked(false);

        // set new marker
        int index = (channel < 0) ? 0 : channel + 3;
        item = fChannelMenu->ItemAt(index);
        if (item)
                item->SetMarked(true);
}


void
MainWin::SelectChannel(int i)
{
        printf("MainWin::SelectChannel %d\n", i);

        if (B_OK != fController->SelectChannel(i))
                return;

        SetChannelMenuMarker();
}


void
MainWin::SelectInterface(int i)
{
        printf("MainWin::SelectInterface %d\n", i);
        printf("  CurrentInterface %d\n", fController->CurrentInterface());
        printf("  CurrentChannel %d\n", fController->CurrentChannel());

        // i = -1 means "None"

        if (i < 0) {
                fController->DisconnectInterface();
                goto done;
        }

        if (!fController->IsInterfaceAvailable(i)) {
                BString s;
                s << B_TRANSLATE("Error, interface is busy:\n\n");
                s << gDeviceRoster->DeviceName(i);
                BAlert* alert = new BAlert("error", s.String(), B_TRANSLATE("OK"));
                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                alert->Go();
                return;
        }

        fController->DisconnectInterface();
        if (fController->ConnectInterface(i) != B_OK) {
                BString s;
                s << B_TRANSLATE("Error, connecting to interface failed:\n\n");
                s << gDeviceRoster->DeviceName(i);
                BAlert* alert = new BAlert("error", s.String(), B_TRANSLATE("OK"));
                alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
                alert->Go();
        }

done:
        printf("MainWin::SelectInterface done:\n");
        printf("  CurrentInterface %d\n", fController->CurrentInterface());
        printf("  CurrentChannel %d\n", fController->CurrentChannel());

        SetInterfaceMenuMarker();
        SetupChannelMenu();
        SetChannelMenuMarker();
}


void
MainWin::SelectInitialInterface()
{
        printf("MainWin::SelectInitialInterface enter\n");

        int count = gDeviceRoster->DeviceCount();
        for (int i = 0; i < count; i++) {
                if (fController->IsInterfaceAvailable(i)
                        && B_OK == fController->ConnectInterface(i)) {
                        printf("MainWin::SelectInitialInterface connected to interface "
                                "%d\n", i);
                        break;
                }
        }

        printf("MainWin::SelectInitialInterface leave\n");
}


bool
MainWin::QuitRequested()
{
        be_app->PostMessage(B_QUIT_REQUESTED);
        return true;
}


void
MainWin::MouseDown(BMessage *msg)
{
        BPoint screen_where;
        uint32 buttons = msg->FindInt32("buttons");

        // On Zeta, only "screen_where" is relyable, "where" and "be:view_where"
        // seem to be broken
        if (B_OK != msg->FindPoint("screen_where", &screen_where)) {
                // Workaround for BeOS R5, it has no "screen_where"
                fVideoView->GetMouse(&screen_where, &buttons, false);
                fVideoView->ConvertToScreen(&screen_where);
        }

//      msg->PrintToStream();

//      if (1 == msg->FindInt32("buttons") && msg->FindInt32("clicks") == 1) {

        if (1 == buttons && msg->FindInt32("clicks") % 2 == 0) {
                BRect r(screen_where.x - 1, screen_where.y - 1, screen_where.x + 1,
                        screen_where.y + 1);
                if (r.Contains(fMouseDownMousePos)) {
                        PostMessage(M_TOGGLE_FULLSCREEN);
                        return;
                }
        }

        if (2 == buttons && msg->FindInt32("clicks") % 2 == 0) {
                BRect r(screen_where.x - 1, screen_where.y - 1, screen_where.x + 1,
                        screen_where.y + 1);
                if (r.Contains(fMouseDownMousePos)) {
                        PostMessage(M_TOGGLE_NO_BORDER_NO_MENU);
                        return;
                }
        }

/*
                // very broken in Zeta:
                fMouseDownMousePos = fVideoView->ConvertToScreen(
                        msg->FindPoint("where"));
*/
        fMouseDownMousePos = screen_where;
        fMouseDownWindowPos = Frame().LeftTop();

        if (buttons == 1 && !fIsFullscreen) {
                // start mouse tracking
                fVideoView->SetMouseEventMask(B_POINTER_EVENTS | B_NO_POINTER_HISTORY
                        /* | B_LOCK_WINDOW_FOCUS */);
                fMouseDownTracking = true;
        }

        // pop up a context menu if right mouse button is down for 200 ms

        if ((buttons & 2) == 0)
                return;
        bigtime_t start = system_time();
        bigtime_t delay = 200000;
        BPoint location;
        do {
                fVideoView->GetMouse(&location, &buttons);
                if ((buttons & 2) == 0)
                        break;
                snooze(1000);
        } while (system_time() - start < delay);

        if (buttons & 2)
                ShowContextMenu(screen_where);
}


void
MainWin::MouseMoved(BMessage *msg)
{
//      msg->PrintToStream();

        BPoint mousePos;
        uint32 buttons = msg->FindInt32("buttons");

        if (1 == buttons && fMouseDownTracking && !fIsFullscreen) {
/*
                // very broken in Zeta:
                BPoint mousePos = msg->FindPoint("where");
                printf("view where: %.0f, %.0f => ", mousePos.x, mousePos.y);
                fVideoView->ConvertToScreen(&mousePos);
*/
                // On Zeta, only "screen_where" is relyable, "where" and
                // "be:view_where" seem to be broken
                if (B_OK != msg->FindPoint("screen_where", &mousePos)) {
                        // Workaround for BeOS R5, it has no "screen_where"
                        fVideoView->GetMouse(&mousePos, &buttons, false);
                        fVideoView->ConvertToScreen(&mousePos);
                }
//              printf("screen where: %.0f, %.0f => ", mousePos.x, mousePos.y);
                float delta_x = mousePos.x - fMouseDownMousePos.x;
                float delta_y = mousePos.y - fMouseDownMousePos.y;
                float x = fMouseDownWindowPos.x + delta_x;
                float y = fMouseDownWindowPos.y + delta_y;
//              printf("move window to %.0f, %.0f\n", x, y);
                MoveTo(x, y);
        }
}


void
MainWin::MouseUp(BMessage *msg)
{
//      msg->PrintToStream();
        fMouseDownTracking = false;
}


void
MainWin::ShowContextMenu(const BPoint &screen_point)
{
        printf("Show context menu\n");
        BPopUpMenu *menu = new BPopUpMenu("context menu", false, false);
        BMenuItem *item;
        menu->AddItem(new BMenuItem(B_TRANSLATE("Scale to native size"),
                new BMessage(M_SCALE_TO_NATIVE_SIZE), 'N', B_COMMAND_KEY));
        menu->AddItem(item = new BMenuItem(B_TRANSLATE("Full screen"),
                new BMessage(M_TOGGLE_FULLSCREEN), 'F', B_COMMAND_KEY));
        item->SetMarked(fIsFullscreen);
        menu->AddSeparatorItem();
        menu->AddItem(item = new BMenuItem(B_TRANSLATE("No menu"),
                new BMessage(M_TOGGLE_NO_MENU), 'M', B_COMMAND_KEY));
        item->SetMarked(fNoMenu);
        menu->AddItem(item = new BMenuItem(B_TRANSLATE("No border"),
                new BMessage(M_TOGGLE_NO_BORDER), 'B', B_COMMAND_KEY));
        item->SetMarked(fNoBorder);
        menu->AddItem(item = new BMenuItem(B_TRANSLATE("Always on top"),
                new BMessage(M_TOGGLE_ALWAYS_ON_TOP), 'T', B_COMMAND_KEY));
        item->SetMarked(fAlwaysOnTop);
        menu->AddItem(item = new BMenuItem(B_TRANSLATE("Keep aspect ratio"),
                new BMessage(M_TOGGLE_KEEP_ASPECT_RATIO), 'K', B_COMMAND_KEY));
        item->SetMarked(fKeepAspectRatio);
        menu->AddSeparatorItem();
        menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
                new BMessage(M_FILE_QUIT), 'Q', B_COMMAND_KEY));

        menu->AddSeparatorItem();
        const char* pixel_aspect = "pixel aspect ratio";
        BString str1 = pixel_aspect;
        str1 << " 1.00000:1";
        menu->AddItem(new BMenuItem(str1.String(),
                new BMessage(M_ASPECT_100000_1)));
        BString str2 = pixel_aspect;
        str2 << " 1.06666:1";
        menu->AddItem(new BMenuItem(str2.String(),
                new BMessage(M_ASPECT_106666_1)));
        BString str3 = pixel_aspect;
        str3 << " 1.09091:1";
        menu->AddItem(new BMenuItem(str3.String(),
                new BMessage(M_ASPECT_109091_1)));
        BString str4 = pixel_aspect;
        str4 << " 1.41176:1";
        menu->AddItem(new BMenuItem(str4.String(),
                new BMessage(M_ASPECT_141176_1)));
        menu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 720 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_720_576)));
        menu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 704 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_704_576)));
        menu->AddItem(new BMenuItem(B_TRANSLATE_COMMENT(
                "force 544 × 576, display aspect 4:3",
                "The '×' is the Unicode multiplication sign U+00D7"),
                new BMessage(M_ASPECT_544_576)));

        menu->SetTargetForItems(this);
        BRect r(screen_point.x - 5, screen_point.y - 5, screen_point.x + 5,
                screen_point.y + 5);
        menu->Go(screen_point, true, true, r, true);
}


void
MainWin::VideoFormatChange(int width, int height, float width_scale,
        float height_scale)
{
        // called when video format or aspect ratio changes

        printf("VideoFormatChange enter: width %d, height %d, width_scale %.6f, "
                "height_scale %.6f\n", width, height, width_scale, height_scale);

        if (width_scale < 1.0 && height_scale >= 1.0) {
                width_scale  = 1.0 / width_scale;
                height_scale = 1.0 / height_scale;
                printf("inverting! new values: width_scale %.6f, height_scale %.6f\n",
                        width_scale, height_scale);
        }

        fSourceWidth  = width;
        fSourceHeight = height;
        fWidthScale   = width_scale;
        fHeightScale  = height_scale;

//      ResizeWindow(Bounds().Width() + 1, Bounds().Height() + 1, true);

        if (fIsFullscreen) {
                AdjustFullscreenRenderer();
        } else {
                AdjustWindowedRenderer(false);
        }

        printf("VideoFormatChange leave\n");

}


void
MainWin::Zoom(BPoint rec_position, float rec_width, float rec_height)
{
        PostMessage(M_TOGGLE_FULLSCREEN);
}


void
MainWin::FrameResized(float new_width, float new_height)
{
        // called when the window got resized
        fFrameResizedCalled = true;

        if (new_width != Bounds().Width() || new_height != Bounds().Height()) {
                debugger("size wrong\n");
        }


        printf("FrameResized enter: new_width %.0f, new_height %.0f, bounds width "
                "%.0f, bounds height %.0f\n", new_width, new_height, Bounds().Width(),
                Bounds().Height());

        if (fIsFullscreen) {

                printf("FrameResized in fullscreen mode\n");

                fIgnoreFrameResized = false;
                AdjustFullscreenRenderer();

        } else {

                if (fFrameResizedTriggeredAutomatically) {
                        fFrameResizedTriggeredAutomatically = false;
                        printf("FrameResized triggered automatically\n");

                        fIgnoreFrameResized = false;

                        AdjustWindowedRenderer(false);
                } else {
                        printf("FrameResized by user in window mode\n");

                        if (fIgnoreFrameResized) {
                                fIgnoreFrameResized = false;
                                printf("FrameResized ignored\n");
                                return;
                        }

                        AdjustWindowedRenderer(true);
                }

        }

        printf("FrameResized leave\n");
}



void
MainWin::UpdateWindowTitle()
{
        BString title;
        title.SetToFormat(B_TRANSLATE_COMMENT("%s - %d × %d, %.3f:%.3f => %.0f × %.0f",
                "The '×' is the Unicode multiplication sign U+00D7"),
                B_TRANSLATE_SYSTEM_NAME(NAME),
                fSourceWidth, fSourceHeight, fWidthScale, fHeightScale,
                fVideoView->Bounds().Width() + 1, fVideoView->Bounds().Height() + 1);
        SetTitle(title);
}


void
MainWin::AdjustFullscreenRenderer()
{
        // n.b. we don't have a menu in fullscreen mode!

        if (fKeepAspectRatio) {

                // Keep aspect ratio, place render inside
                // the background area (may create black bars).
                float max_width  = fBackground->Bounds().Width() + 1.0f;
                float max_height = fBackground->Bounds().Height() + 1.0f;
                float scaled_width  = fSourceWidth * fWidthScale;
                float scaled_height = fSourceHeight * fHeightScale;
                float factor = min_c(max_width / scaled_width, max_height
                        / scaled_height);
                int render_width = int(scaled_width * factor);
                int render_height = int(scaled_height * factor);
                int x_ofs = (int(max_width) - render_width) / 2;
                int y_ofs = (int(max_height) - render_height) / 2;

                printf("AdjustFullscreenRenderer: background %.1f x %.1f, src video "
                        "%d x %d, scaled video %.3f x %.3f, factor %.3f, render %d x %d, "
                        "x-ofs %d, y-ofs %d\n", max_width, max_height, fSourceWidth,
                        fSourceHeight, scaled_width, scaled_height, factor, render_width,
                        render_height, x_ofs, y_ofs);

                fVideoView->MoveTo(x_ofs, y_ofs);
                fVideoView->ResizeTo(render_width - 1, render_height - 1);

        } else {

                printf("AdjustFullscreenRenderer: using whole background area\n");

                // no need to keep aspect ratio, make
                // render cover the whole background
                fVideoView->MoveTo(0, 0);
                fVideoView->ResizeTo(fBackground->Bounds().Width(),
                        fBackground->Bounds().Height());

        }
}


void
MainWin::AdjustWindowedRenderer(bool user_resized)
{
        printf("AdjustWindowedRenderer enter - user_resized %d\n", user_resized);

        // In windowed mode, the renderer always covers the
        // whole background, accounting for the menu
        fVideoView->MoveTo(0, fNoMenu ? 0 : fMenuBarHeight);
        fVideoView->ResizeTo(fBackground->Bounds().Width(),
                fBackground->Bounds().Height() - (fNoMenu ? 0 : fMenuBarHeight));

        if (fKeepAspectRatio) {
                // To keep the aspect ratio correct, we
                // do resize the window as required

                float max_width  = Bounds().Width() + 1.0f;
                float max_height = Bounds().Height() + 1.0f - (fNoMenu ? 0
                        : fMenuBarHeight);
                float scaled_width  = fSourceWidth * fWidthScale;
                float scaled_height = fSourceHeight * fHeightScale;

                if (!user_resized && (scaled_width > max_width
                        || scaled_height > max_height)) {
                        // A format switch occured, and the window was
                        // smaller then the video source. As it was not
                        // initiated by the user resizing the window, we
                        // enlarge the window to fit the video.
                        fIgnoreFrameResized = true;
                        ResizeTo(scaled_width - 1, scaled_height - 1
                                + (fNoMenu ? 0 : fMenuBarHeight));
//                      Sync();
                        return;
                }

                float display_aspect_ratio = scaled_width / scaled_height;
                int new_width  = int(max_width);
                int new_height = int(max_width / display_aspect_ratio + 0.5);

                printf("AdjustWindowedRenderer: old display %d x %d, src video "
                        "%d x %d, scaled video %.3f x %.3f, aspect ratio %.3f, new "
                        "display %d x %d\n", int(max_width), int(max_height),
                        fSourceWidth, fSourceHeight, scaled_width, scaled_height,
                        display_aspect_ratio, new_width, new_height);

                fIgnoreFrameResized = true;
                ResizeTo(new_width - 1, new_height - 1 + (fNoMenu ? 0
                        : fMenuBarHeight));
//              Sync();
        }

        printf("AdjustWindowedRenderer leave\n");
}


void
MainWin::ToggleNoBorderNoMenu()
{
        if (!fNoMenu && fNoBorder) {
                // if no border, switch of menu, too
                PostMessage(M_TOGGLE_NO_MENU);
        } else
        if (fNoMenu && !fNoBorder) {
                // if no menu, switch of border, too
                PostMessage(M_TOGGLE_NO_BORDER);
        } else {
                // both are either on or off, toggle both
                PostMessage(M_TOGGLE_NO_MENU);
                PostMessage(M_TOGGLE_NO_BORDER);
        }
}


void
MainWin::ToggleFullscreen()
{
        printf("ToggleFullscreen enter\n");

        if (!fFrameResizedCalled) {
                printf("ToggleFullscreen - ignoring, as FrameResized wasn't called "
                        "since last switch\n");
                return;
        }
        fFrameResizedCalled = false;


        fIsFullscreen = !fIsFullscreen;

        if (fIsFullscreen) {
                // switch to fullscreen

                // Sync here is probably not required
//              Sync();

                fSavedFrame = Frame();
                printf("saving current frame: %d %d %d %d\n", int(fSavedFrame.left),
                        int(fSavedFrame.top), int(fSavedFrame.right),
                        int(fSavedFrame.bottom));
                BScreen screen(this);
                BRect rect(screen.Frame());

                Hide();
                if (!fNoMenu) {
                        // if we have a menu, remove it now
                        fMenuBar->Hide();
                }
                fFrameResizedTriggeredAutomatically = true;
                MoveTo(rect.left, rect.top);
                ResizeTo(rect.Width(), rect.Height());
                Show();

//              Sync();

        } else {
                // switch back from full screen mode

                Hide();
                // if we need a menu, show it now
                if (!fNoMenu) {
                        fMenuBar->Show();
                }
                fFrameResizedTriggeredAutomatically = true;
                MoveTo(fSavedFrame.left, fSavedFrame.top);
                ResizeTo(fSavedFrame.Width(), fSavedFrame.Height());
                Show();

                // We *must* make sure that the window is at
                // the correct position before continuing, or
                // rapid fullscreen switching by holding down
                // the TAB key will expose strange bugs.
                // Never remove this Sync!
//              Sync();
        }

        // FrameResized() will do the required adjustments

        printf("ToggleFullscreen leave\n");
}


void
MainWin::ToggleNoMenu()
{
        printf("ToggleNoMenu enter\n");

        fNoMenu = !fNoMenu;

        if (fIsFullscreen) {
                // fullscreen is always without menu
                printf("ToggleNoMenu leave, doing nothing, we are fullscreen\n");
                return;
        }

//      fFrameResizedTriggeredAutomatically = true;
        fIgnoreFrameResized = true;

        if (fNoMenu) {
                fMenuBar->Hide();
                fVideoView->MoveTo(0, 0);
                fVideoView->ResizeBy(0, fMenuBarHeight);
                MoveBy(0, fMenuBarHeight);
                ResizeBy(0, - fMenuBarHeight);
//              Sync();
        } else {
                fMenuBar->Show();
                fVideoView->MoveTo(0, fMenuBarHeight);
                fVideoView->ResizeBy(0, -fMenuBarHeight);
                MoveBy(0, - fMenuBarHeight);
                ResizeBy(0, fMenuBarHeight);
//              Sync();
        }

        printf("ToggleNoMenu leave\n");
}


void
MainWin::ToggleNoBorder()
{
        printf("ToggleNoBorder enter\n");
        fNoBorder = !fNoBorder;
//      SetLook(fNoBorder ? B_NO_BORDER_WINDOW_LOOK : B_TITLED_WINDOW_LOOK);
        SetLook(fNoBorder ? B_BORDERED_WINDOW_LOOK : B_TITLED_WINDOW_LOOK);
        printf("ToggleNoBorder leave\n");
}


void
MainWin::ToggleAlwaysOnTop()
{
        printf("ToggleAlwaysOnTop enter\n");
        fAlwaysOnTop = !fAlwaysOnTop;
        SetFeel(fAlwaysOnTop ? B_FLOATING_ALL_WINDOW_FEEL : B_NORMAL_WINDOW_FEEL);
        printf("ToggleAlwaysOnTop leave\n");
}


void
MainWin::ToggleKeepAspectRatio()
{
        printf("ToggleKeepAspectRatio enter\n");
        fKeepAspectRatio = !fKeepAspectRatio;

        fFrameResizedTriggeredAutomatically = true;
        FrameResized(Bounds().Width(), Bounds().Height());
//      if (fIsFullscreen) {
//              AdjustFullscreenRenderer();
//      } else {
//              AdjustWindowedRenderer(false);
//      }
        printf("ToggleKeepAspectRatio leave\n");
}


/* Trap keys that are about to be send to background or renderer view.
 * Return B_OK if it shouldn't be passed to the view
 */
status_t
MainWin::KeyDown(BMessage *msg)
{
//      msg->PrintToStream();

        uint32 key               = msg->FindInt32("key");
        uint32 raw_char  = msg->FindInt32("raw_char");
        uint32 modifiers = msg->FindInt32("modifiers");

        printf("key 0x%" B_PRIx32 ", raw_char 0x%" B_PRIx32 ", modifiers 0x%" B_PRIx32 "\n", key, raw_char,
                modifiers);

        switch (raw_char) {
                case B_SPACE:
                        PostMessage(M_TOGGLE_NO_BORDER_NO_MENU);
                        return B_OK;

                case B_ESCAPE:
                        if (fIsFullscreen) {
                                PostMessage(M_TOGGLE_FULLSCREEN);
                                return B_OK;
                        } else
                                break;

                case B_ENTER:           // Enter / Return
                        if (modifiers & B_COMMAND_KEY) {
                                PostMessage(M_TOGGLE_FULLSCREEN);
                                return B_OK;
                        } else
                                break;

                case B_TAB:
                        if ((modifiers & (B_COMMAND_KEY | B_CONTROL_KEY | B_OPTION_KEY
                                | B_MENU_KEY)) == 0) {
                                PostMessage(M_TOGGLE_FULLSCREEN);
                                return B_OK;
                        } else
                                break;

                case B_UP_ARROW:
                        if (modifiers & B_COMMAND_KEY) {
                                PostMessage(M_CHANNEL_NEXT);
                        } else {
                                PostMessage(M_VOLUME_UP);
                        }
                        return B_OK;

                case B_DOWN_ARROW:
                        if (modifiers & B_COMMAND_KEY) {
                                PostMessage(M_CHANNEL_PREV);
                        } else {
                                PostMessage(M_VOLUME_DOWN);
                        }
                        return B_OK;

                case B_RIGHT_ARROW:
                        if (modifiers & B_COMMAND_KEY) {
                                PostMessage(M_VOLUME_UP);
                        } else {
                                PostMessage(M_CHANNEL_NEXT);
                        }
                        return B_OK;

                case B_LEFT_ARROW:
                        if (modifiers & B_COMMAND_KEY) {
                                PostMessage(M_VOLUME_DOWN);
                        } else {
                                PostMessage(M_CHANNEL_PREV);
                        }
                        return B_OK;

                case B_PAGE_UP:
                        PostMessage(M_CHANNEL_NEXT);
                        return B_OK;

                case B_PAGE_DOWN:
                        PostMessage(M_CHANNEL_PREV);
                        return B_OK;
        }

        switch (key) {
                case 0x3a:              // numeric keypad +
                        if ((modifiers & B_COMMAND_KEY) == 0) {
                                printf("if\n");
                                PostMessage(M_VOLUME_UP);
                                return B_OK;
                        } else {
                                printf("else\n");
                                break;
                        }

                case 0x25:              // numeric keypad -
                        if ((modifiers & B_COMMAND_KEY) == 0) {
                                PostMessage(M_VOLUME_DOWN);
                                return B_OK;
                        } else {
                                break;
                        }

                case 0x38:                      // numeric keypad up arrow
                        PostMessage(M_VOLUME_UP);
                        return B_OK;

                case 0x59:                      // numeric keypad down arrow
                        PostMessage(M_VOLUME_DOWN);
                        return B_OK;

                case 0x39:                      // numeric keypad page up
                case 0x4a:                      // numeric keypad right arrow
                        PostMessage(M_CHANNEL_NEXT);
                        return B_OK;

                case 0x5a:                      // numeric keypad page down
                case 0x48:                      // numeric keypad left arrow
                        PostMessage(M_CHANNEL_PREV);
                        return B_OK;
        }

        return B_ERROR;
}


void
MainWin::DispatchMessage(BMessage *msg, BHandler *handler)
{
        if ((msg->what == B_MOUSE_DOWN) && (handler == fBackground
                || handler == fVideoView))
                MouseDown(msg);
        if ((msg->what == B_MOUSE_MOVED) && (handler == fBackground
                || handler == fVideoView))
                MouseMoved(msg);
        if ((msg->what == B_MOUSE_UP) && (handler == fBackground
                || handler == fVideoView))
                MouseUp(msg);

        if ((msg->what == B_KEY_DOWN) && (handler == fBackground
                || handler == fVideoView)) {

                // special case for PrintScreen key
                if (msg->FindInt32("key") == B_PRINT_KEY) {
                        fVideoView->OverlayScreenshotPrepare();
                        BWindow::DispatchMessage(msg, handler);
                        fVideoView->OverlayScreenshotCleanup();
                        return;
                }

                // every other key gets dispatched to our KeyDown first
                if (KeyDown(msg) == B_OK) {
                        // it got handled, don't pass it on
                        return;
                }
        }

        BWindow::DispatchMessage(msg, handler);
}


void
MainWin::MessageReceived(BMessage *msg)
{
        switch (msg->what) {
                case B_ACQUIRE_OVERLAY_LOCK:
                        printf("B_ACQUIRE_OVERLAY_LOCK\n");
                        fVideoView->OverlayLockAcquire();
                        break;

                case B_RELEASE_OVERLAY_LOCK:
                        printf("B_RELEASE_OVERLAY_LOCK\n");
                        fVideoView->OverlayLockRelease();
                        break;

                case B_MOUSE_WHEEL_CHANGED:
                {
                        printf("B_MOUSE_WHEEL_CHANGED\n");
                        float dx = msg->FindFloat("be:wheel_delta_x");
                        float dy = msg->FindFloat("be:wheel_delta_y");
                        bool inv = modifiers() & B_COMMAND_KEY;
                        if (dx > 0.1)   PostMessage(inv ? M_VOLUME_DOWN : M_CHANNEL_PREV);
                        if (dx < -0.1)  PostMessage(inv ? M_VOLUME_UP : M_CHANNEL_NEXT);
                        if (dy > 0.1)   PostMessage(inv ? M_CHANNEL_PREV : M_VOLUME_DOWN);
                        if (dy < -0.1)  PostMessage(inv ? M_CHANNEL_NEXT : M_VOLUME_UP);
                        break;
                }

                case M_CHANNEL_NEXT:
                {
                        printf("M_CHANNEL_NEXT\n");
                        int chan = fController->CurrentChannel();
                        if (chan != -1) {
                                chan++;
                                if (chan < fController->ChannelCount())
                                        SelectChannel(chan);
                        }
                        break;
                }

                case M_CHANNEL_PREV:
                {
                        printf("M_CHANNEL_PREV\n");
                        int chan = fController->CurrentChannel();
                        if (chan != -1) {
                                chan--;
                                if (chan >= 0)
                                        SelectChannel(chan);
                        }
                        break;
                }

                case M_VOLUME_UP:
                        printf("M_VOLUME_UP\n");
                        fController->VolumeUp();
                        break;

                case M_VOLUME_DOWN:
                        printf("M_VOLUME_DOWN\n");
                        fController->VolumeDown();
                        break;

                case M_ASPECT_100000_1:
                        VideoFormatChange(fSourceWidth, fSourceHeight, 1.0, 1.0);
                        break;

                case M_ASPECT_106666_1:
                        VideoFormatChange(fSourceWidth, fSourceHeight, 1.06666, 1.0);
                        break;

                case M_ASPECT_109091_1:
                        VideoFormatChange(fSourceWidth, fSourceHeight, 1.09091, 1.0);
                        break;

                case M_ASPECT_141176_1:
                        VideoFormatChange(fSourceWidth, fSourceHeight, 1.41176, 1.0);
                        break;

                case M_ASPECT_720_576:
                        VideoFormatChange(720, 576, 1.06666, 1.0);
                        break;

                case M_ASPECT_704_576:
                        VideoFormatChange(704, 576, 1.09091, 1.0);
                        break;

                case M_ASPECT_544_576:
                        VideoFormatChange(544, 576, 1.41176, 1.0);
                        break;

                case B_REFS_RECEIVED:
                        printf("MainWin::MessageReceived: B_REFS_RECEIVED\n");
//                      RefsReceived(msg);
                        break;

                case B_SIMPLE_DATA:
                        printf("MainWin::MessageReceived: B_SIMPLE_DATA\n");
//                      if (msg->HasRef("refs"))
//                              RefsReceived(msg);
                        break;

                case M_FILE_QUIT:
//                      be_app->PostMessage(B_QUIT_REQUESTED);
                        PostMessage(B_QUIT_REQUESTED);
                        break;

                case M_SCALE_TO_NATIVE_SIZE:
                        printf("M_SCALE_TO_NATIVE_SIZE\n");
                        if (fIsFullscreen) {
                                ToggleFullscreen();
                        }
                        ResizeTo(int(fSourceWidth * fWidthScale),
                                         int(fSourceHeight * fHeightScale) + (fNoMenu ? 0
                                                : fMenuBarHeight));
//                      Sync();
                        break;

                case M_TOGGLE_FULLSCREEN:
                        ToggleFullscreen();
                        fSettingsMenu->ItemAt(1)->SetMarked(fIsFullscreen);
                        break;

                case M_TOGGLE_NO_MENU:
                        ToggleNoMenu();
                        fSettingsMenu->ItemAt(3)->SetMarked(fNoMenu);
                        break;

                case M_TOGGLE_NO_BORDER:
                        ToggleNoBorder();
                        fSettingsMenu->ItemAt(4)->SetMarked(fNoBorder);
                        break;

                case M_TOGGLE_ALWAYS_ON_TOP:
                        ToggleAlwaysOnTop();
                        fSettingsMenu->ItemAt(5)->SetMarked(fAlwaysOnTop);
                        break;

                case M_TOGGLE_KEEP_ASPECT_RATIO:
                        ToggleKeepAspectRatio();
                        fSettingsMenu->ItemAt(6)->SetMarked(fKeepAspectRatio);
                        break;

                case M_TOGGLE_NO_BORDER_NO_MENU:
                        ToggleNoBorderNoMenu();
                        break;

                case M_PREFERENCES:
                        break;

                default:
                        if (msg->what >= M_SELECT_CHANNEL
                                && msg->what <= M_SELECT_CHANNEL_END) {
                                SelectChannel(msg->what - M_SELECT_CHANNEL);
                                break;
                        }
                        if (msg->what >= M_SELECT_INTERFACE
                                && msg->what <= M_SELECT_INTERFACE_END) {
                                SelectInterface(msg->what - M_SELECT_INTERFACE - 1);
                                break;
                        }

                        BWindow::MessageReceived(msg);
        }
}