Quellcode-Bibliothek generic_window.hpp   Sprache: C

/*****************************************************************************
 * generic_window.hpp
 ****************************************************** *******
AN team
 *
                   bool dragDrop,bool playOnDrop,
 *                   type  TopWindow ;
 *
 *     void (EvtFocus rEvtFocus ){ (oid); java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  it under the of GNU General Public    by
  the  Software ;either   of  License, or
  (at  )any later .
 *
 * This         { ()EvtDragDrop;}
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * virtualvoid resize(int ,int height ;
 * GNU General Public License for more details.
 *
 * You shouldjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*with  program;if not,write  the  Software Foundation,Inc.java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
     int getWidth( const { m_width;}
 *****************************************************************************/

#ifndef GENERIC_WINDOW_HPP
#efine 

#include    /// Give access to the visibility variable
    VarBool &etVisibleVar() { return*; java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

class OSWindow;
virtual:stringgetType()const { Generic" java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
class EvtFocus;
class EvtLeave;
class EvtMenu;
class     /// window type
    W getType( {returnm_type java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

class         int  0,int y =0,  =-,   1)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
class      *getOSWindow( const { return m_pOsWindow;}
class EvtDragLeave/// Method called when the window is destroyed by the WM
  virtual void onDestroyed( {m_pVarVisible-set(alse) }
class
protected:
struct


/// Generic window class
class GenericWindow: public SkinObject/// only by the window manager or by inheritant classes.
{
private:
    friend class WindowManager;
    friend class VoutManager      show( const;
    /// Hide
public:virtualvoidhide( const;

    enum WindowType_t  (int ,inttop)
    {
        TopWindow    // Bring the window on top
VoutWindow,
        FullscreenWindow,
        java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
    };

    GenericWindow( intf_thread_t *
                   /// Toggle the window on top
                   *  NULL,
                   WindowType_t type =TopWindow ;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    
    
    virtual voidinnerHide(;
virtual void processEvent(EvtMotion &rEvtMotion ) {(oid)EvtMotion }
    virtual    bool isVisible()const {return m_pVarVisible-(;}
    /// Method
    virtual void processEvent(    void onUpdate(Subject<VarBool> &Variable , void*;
        WindowT m_type;

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{(void)EvtDragEnter;}
    virtual void processEvent(    /// OS specific implementation
eave }
        //Variable for the visibility of the window
    {(void)EvtDragOver;}
    virtual void}
        { (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

    virtual void processEvent( EvtRefresh &rEvtRefresh );

    /// Resize the window
    virtual void resize( int width, int height );

    /// Refresh an area of the window
    virtual void refresh( int left, int top, int width, int height )
        { (void)left; (void)top; (void)width; (void)height; }

    /// Invalidate an area of the window
    virtual void invalidateRect( int left, int top, int width, int height );

    /// Get the coordinates of the window
    int getLeft() const { return m_left; }
    int getTop() const { return m_top; }
    int getWidth() const { return m_width; }
    int getHeight() const { return m_height; }
    void getMonitorInfo( int* x, int* y, int* width, int* height ) const;

    /// Give access to the visibility variable
    VarBool &getVisibleVar() { return *m_pVarVisible; }

    /// Window type, mainly useful when overloaded (for VoutWindow)
    virtual std::string getType() const { return "Generic"; }

    /// window handle
    void updateWindowConfiguration( struct vlc_window *pWnd ) const;

    /// window type
    WindowType_t getType() { return m_type; }

    /// reparent
    void setParent( GenericWindow* pParent,
                    int x = 0, int y = 0, int w = -1, int h = -1 );

    /// Get the OS window
    OSWindow *getOSWindow() const { return m_pOsWindow; }

    /// Method called when the window is destroyed by the WM
    virtual void onDestroyed() { m_pVarVisible->set(false); }

protected:

    /// These methods do not need to be public since they are accessed
    /// only by the window manager or by inheritant classes.
    //@{
    /// Show the window
    virtual void show() const;

    /// Hide the window
    virtual void hide() const;

    /// Move the window
    virtual void move( int left, int top );

    /// Bring the window on top
    virtual void raise() const;

    /// Set the opacity of the window (0 = transparent, 255 = opaque)
    virtual void setOpacity( uint8_t value );

    /// Toggle the window on top
    virtual void toggleOnTop( bool onTop ) const;
    //@}

    /// Actually show the window
    virtual void innerShow();

    /// Actually hide the window
    virtual void innerHide();

    ///
    bool isVisible() const { return m_pVarVisible->get(); }

    /// Method called when the observed variable is modified
    virtual void onUpdate( Subject<VarBool> &rVariable , void*);

private:
    WindowType_t m_type;
    /// Window position and size
    int m_left, m_top, m_width, m_height;
    /// OS specific implementation
    OSWindow *m_pOsWindow;
    /// Variable for the visibility of the window
    mutable VarBoolImpl *m_pVarVisible;
};


#endif