/*
 * Copyright 2020 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stefano Ceccherini <stefano.ceccherini@gmail.com>
 */
#ifndef _DIRECT_WINDOW_H
#define _DIRECT_WINDOW_H


#include <Region.h>
#include <Window.h>


enum direct_buffer_state {
        B_DIRECT_MODE_MASK = 15,
        B_DIRECT_START = 0,
        B_DIRECT_STOP = 1,
        B_DIRECT_MODIFY = 2,
        B_CLIPPING_MODIFIED = 16,
        B_BUFFER_RESIZED = 32,
        B_BUFFER_MOVED = 64,
        B_BUFFER_RESET = 128
};


enum direct_driver_state {
        B_DRIVER_CHANGED = 0x0001,
        B_MODE_CHANGED = 0x0002
};


typedef struct {
        direct_buffer_state     buffer_state;
        direct_driver_state     driver_state;
        void                            *bits;
        addr_t                          _reserved; // was pci_bits
        int32                           bytes_per_row;
        uint32                          bits_per_pixel;
        color_space                     pixel_format;
        buffer_layout           layout;
        buffer_orientation      orientation;
        area_id                         bits_area;
        uint32                          _reserved1[10];
        uint32                          clip_list_count;
        clipping_rect           window_bounds;
        clipping_rect           clip_bounds;
        clipping_rect           clip_list[1];
} direct_buffer_info;


class BDirectWindow : public BWindow {
public:
                                                                BDirectWindow(BRect frame, const char* title,
                                                                        window_type type, uint32 flags,
                                                                        uint32 workspace = B_CURRENT_WORKSPACE);

                                                                BDirectWindow(BRect frame, const char* title,
                                                                        window_look look, window_feel feel,
                                                                        uint32 flags,
                                                                        uint32 workspace = B_CURRENT_WORKSPACE);

        virtual                                         ~BDirectWindow();

        static  BArchivable*            Instantiate(BMessage* data);
        virtual status_t                        Archive(BMessage* data,
                                                                        bool deep = true) const;

        virtual void                            Quit();

        virtual void                            DispatchMessage(BMessage* message,
                                                                        BHandler* handler);

        virtual void                            MessageReceived(BMessage* message);

        virtual void                            FrameMoved(BPoint newPosition);
        virtual void                            FrameResized(float newWidth, float newHeight);

        virtual void                            WorkspacesChanged(uint32 oldWorkspaces,
                                                                        uint32 newWorkspaces);

        virtual void                            WorkspaceActivated(int32 workspaceIndex,
                                                                        bool state);

        virtual void                            Minimize(bool minimize);
        virtual void                            Zoom(BPoint recPosition, float recWidth,
                                                                        float recHeight);

        virtual void                            ScreenChanged(BRect screenFrame,
                                                                        color_space depth);

        virtual void                            MenusBeginning();
        virtual void                            MenusEnded();
        virtual void                            WindowActivated(bool state);
        virtual void                            Show();
        virtual void                            Hide();

        virtual BHandler*                       ResolveSpecifier(BMessage* message,
                                                                        int32 index, BMessage* specifier,
                                                                        int32 what, const char* property);

        virtual status_t                        GetSupportedSuites(BMessage* data);
        virtual status_t                        Perform(perform_code code, void* arg);

        virtual void                            DirectConnected(direct_buffer_info* info);

                        status_t                        GetClippingRegion(BRegion* region,
                                                                        BPoint* origin = NULL) const;

                        status_t                        SetFullScreen(bool enable);
                        bool                            IsFullScreen() const;

        static  bool                            SupportsWindowMode(
                                                                        screen_id id = B_MAIN_SCREEN_ID);
private:
                                                                BDirectWindow();
                                                                BDirectWindow(BDirectWindow& other);

                        BDirectWindow&          operator=(BDirectWindow& other);

        typedef BWindow                         inherited;

        virtual void                            _ReservedDirectWindow1();
        virtual void                            _ReservedDirectWindow2();
        virtual void                            _ReservedDirectWindow3();
        virtual void                            _ReservedDirectWindow4();

        virtual void                            task_looper();
        virtual BMessage*                       ConvertToMessage(void* raw, int32 code);

        static  int32                           _daemon_thread(void* arg);
                        int32                           _DirectDaemon();
                        bool                            _LockDirect() const;
                        void                            _UnlockDirect() const;
                        void                            _InitData();
                        void                            _DisposeData();
private:
                        bool                            fDaemonKiller;
                        bool                            fConnectionEnable;
                        bool                            fIsFullScreen;
                        bool                            _unused;
                        bool                            fInDirectConnected;
                        int32                           fDirectLock;
                        sem_id                          fDirectSem;
                        uint32                          fDirectLockCount;
                        thread_id                       fDirectLockOwner;
                        char*                           fDirectLockStack;
                        sem_id                          fDisableSem;
                        sem_id                          fDisableSemAck;

                        uint32                          fInitStatus;

                        uint32                          _reserved[2];

                        area_id                         fSourceDirectArea;
                        area_id                         fClonedDirectArea;
                        area_id                         fSourceBitsArea;
                        thread_id                       fDirectDaemonId;
                        direct_buffer_info*     fBufferDesc;

                        uint32                          _more_reserved_[17];
};

#endif