/*
 * Copyright 2008 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Julun, <host.haiku@gmx.de
 */

#include <PrintPanel.h>

#include <Button.h>
#include <GroupLayoutBuilder.h>
#include <GroupView.h>
#include <Screen.h>


namespace BPrivate {
        namespace Print {


// #pragma mark -- _BPrintPanelFilter_


BPrintPanel::_BPrintPanelFilter_::_BPrintPanelFilter_(BPrintPanel* panel)
        : BMessageFilter(B_KEY_DOWN)
        , fPrintPanel(panel)
{
}


filter_result
BPrintPanel::_BPrintPanelFilter_::Filter(BMessage* msg, BHandler** target)
{
        int32 key;
        filter_result result = B_DISPATCH_MESSAGE;
        if (msg->FindInt32("key", &key) == B_OK && key == 1) {
                fPrintPanel->PostMessage(B_QUIT_REQUESTED);
                result = B_SKIP_MESSAGE;
        }
        return result;
}


// #pragma mark -- BPrintPanel


BPrintPanel::BPrintPanel(const BString& title)
        : BWindow(BRect(0, 0, 640, 480), title.String(), B_TITLED_WINDOW_LOOK,
                B_MODAL_APP_WINDOW_FEEL, B_NOT_ZOOMABLE | B_NOT_RESIZABLE |
                B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS | B_CLOSE_ON_ESCAPE)
        , fPanel(new BGroupView)
        , fPrintPanelSem(-1)
        , fPrintPanelResult(B_CANCEL)
{
        BButton* ok = new BButton("OK", new BMessage('_ok_'));
        BButton* cancel = new BButton("Cancel", new BMessage('_cl_'));

        BGroupLayout *layout = new BGroupLayout(B_HORIZONTAL);
        SetLayout(layout);

        AddChild(BGroupLayoutBuilder(B_VERTICAL, 10.0)
                        .Add(fPanel)
                        .Add(BGroupLayoutBuilder(B_HORIZONTAL, 10.0)
                                .AddGlue()
                                .Add(cancel)
                                .Add(ok)
                                .SetInsets(0.0, 0.0, 0.0, 0.0))
                        .SetInsets(10.0, 10.0, 10.0, 10.0)
                );

        ok->MakeDefault(true);
        AddCommonFilter(new _BPrintPanelFilter_(this));
}


BPrintPanel::~BPrintPanel()
{
        if (fPrintPanelSem > 0)
                delete_sem(fPrintPanelSem);
}


BPrintPanel::BPrintPanel(BMessage* data)
        : BWindow(data)
{
        // TODO: implement
}


BArchivable*
BPrintPanel::Instantiate(BMessage* data)
{
        // TODO: implement
        return NULL;
}


status_t
BPrintPanel::Archive(BMessage* data, bool deep) const
{
        // TODO: implement
        return B_ERROR;
}


BView*
BPrintPanel::Panel() const
{
        return fPanel->ChildAt(0);
}


void
BPrintPanel::AddPanel(BView* panel)
{
        BView* child = Panel();
        if (child) {
                RemovePanel(child);
                delete child;
        }

        fPanel->AddChild(panel);

        BSize size = GetLayout()->PreferredSize();
        ResizeTo(size.Width(), size.Height());
}


bool
BPrintPanel::RemovePanel(BView* child)
{
        BView* panel = Panel();
        if (child == panel)
                return fPanel->RemoveChild(child);

        return false;
}


void
BPrintPanel::MessageReceived(BMessage* message)
{
        switch (message->what) {
                case '_ok_': {
                        fPrintPanelResult = B_OK;

                // fall through
                case '_cl_':
                        delete_sem(fPrintPanelSem);
                        fPrintPanelSem = -1;
                }       break;

                default:
                        BWindow::MessageReceived(message);
        }
}


void
BPrintPanel::FrameResized(float newWidth, float newHeight)
{
        BWindow::FrameResized(newWidth, newHeight);
}


BHandler*
BPrintPanel::ResolveSpecifier(BMessage* message, int32 index, BMessage* specifier,
        int32 form, const char* property)
{
        return BWindow::ResolveSpecifier(message, index, specifier, form, property);
}


status_t
BPrintPanel::GetSupportedSuites(BMessage* data)
{
        return BWindow::GetSupportedSuites(data);
}


status_t
BPrintPanel::Perform(perform_code d, void* arg)
{
        return BWindow::Perform(d, arg);
}


void
BPrintPanel::Quit()
{
        BWindow::Quit();
}


bool
BPrintPanel::QuitRequested()
{
        return BWindow::QuitRequested();
}


void
BPrintPanel::DispatchMessage(BMessage* message, BHandler* handler)
{
        BWindow::DispatchMessage(message, handler);
}


status_t
BPrintPanel::ShowPanel()
{
        fPrintPanelSem = create_sem(0, "PrintPanel");
        if (fPrintPanelSem < 0) {
                Quit();
                return B_CANCEL;
        }

        BWindow* window = dynamic_cast<BWindow*> (BLooper::LooperForThread(find_thread(NULL)));

        {
                BRect bounds(Bounds());
                BRect frame(BScreen(B_MAIN_SCREEN_ID).Frame());
                MoveTo((frame.Width() - bounds.Width()) / 2.0,
                        (frame.Height() - bounds.Height()) / 2.0);
        }

        Show();

        if (window) {
                status_t err;
                while (true) {
                        do {
                                err = acquire_sem_etc(fPrintPanelSem, 1, B_RELATIVE_TIMEOUT, 50000);
                        } while (err == B_INTERRUPTED);

                        if (err == B_BAD_SEM_ID)
                                break;
                        window->UpdateIfNeeded();
                }
        } else {
                while (acquire_sem(fPrintPanelSem) == B_INTERRUPTED) {}
        }

        return fPrintPanelResult;
}


void
BPrintPanel::AddChild(BView* child, BView* before)
{
        BWindow::AddChild(child, before);
}


bool
BPrintPanel::RemoveChild(BView* child)
{
        return BWindow::RemoveChild(child);
}


BView*
BPrintPanel::ChildAt(int32 index) const
{
        return BWindow::ChildAt(index);
}


void BPrintPanel::_ReservedBPrintPanel1() {}
void BPrintPanel::_ReservedBPrintPanel2() {}
void BPrintPanel::_ReservedBPrintPanel3() {}
void BPrintPanel::_ReservedBPrintPanel4() {}
void BPrintPanel::_ReservedBPrintPanel5() {}


        }       // namespace Print
}       // namespace BPrivate