CascadeVesselPanel.h

Go to the documentation of this file.

//
// CascadeVesselPanel.h - interface of class CascadeVesselPanel
// This class allows client apps to create a panel on the screen that
// contains vessels.  For the time being, it will only allow vessels in a
// vertical configuration.
// Copyright (c) 2003, Roku, LLC.  All rights reserved.
//

#ifndef _ROKU_INCLUDE_CASCADE_WIDGETS_CASCADEVESSELPANEL_H
#define _ROKU_INCLUDE_CASCADE_WIDGETS_CASCADEVESSELPANEL_H

#include <cascade/widgets/CascadeWidget.h>
#include <cascade/util/CascadeString.h>
#include <cascade/util/CascadeArray.h>
#include <cascade/app/CascadeMountMessage.h>
#include <cascade/util/CascadeDirBrowser.h>
#include <cascade/util/CascadeSettings.h>
#include <cascade/util/CascadeVessel.h>
#include <cascade/interprocess/CascadeWormhole.h>
#include <cascade/app/CascadeApp.h>

#define _CASCADE_VESSEL_SETTINGS_SECTION      "cascade-widgets-vessel"
#define _CASCADE_VESSEL_VARNAME_DIR_CHOOSE    "dirchoose"
#define _CASCADE_VESSEL_DEFAULT_DIR_CHOOSE    0

#define MAX_VISIBLE_VESSELS 4
#define MAX_VESSELS 16

#define _VESSEL_PANEL_VESSELCHANGE_MESSAGE "com.roku.cascade.vesselpanel.activevesselchange"

class CascadeVesselPanel: public CascadeWidget
{
    public:
    CascadeVesselPanel();
    virtual ~CascadeVesselPanel();



    void SetAcquireGraphicsOnPaint(bool bAcquireOnPaint){m_bAcquireOnPaint = bAcquireOnPaint;}

    typedef void (ActiveVesselChangeCallback)(const Vessel * newActiveVessel, void * pClientData);
        typedef void (VesselInsertedCallback)(const Vessel * newActiveVessel, void * pClientData);
        typedef void (VesselRemovedCallback)(const CascadeString & vesselMountPath, void * pClientData);
    void RegisterActiveVesselChangeCallback(ActiveVesselChangeCallback * pCallback, void * pClientData);
        void RegisterVesselWorkingPathChangeCallback(ActiveVesselChangeCallback * pCallback, void * pClientData);
    void RegisterVesselInsertedCallback(VesselInsertedCallback * pCallback, void * pClientData);
        void RegisterVesselRemovedCallback(VesselRemovedCallback * pCallback, void * pClientData);
        
        void OnMountMessage(const CascadeMountMessage & mountMessage);
 
    Vessel* GetActiveVessel();
    u8  GetActiveVesselIndex(){return m_nActiveVessel;}
    Vessel* GetVesselAt(u8 index);
    bool SetActiveVessel(Vessel* pVessel, bool bNotify = true);
        bool SetActiveVessel(CascadeString path, bool bNotify = true);
        bool SetActiveVessel(u32 idx, bool bFullRepaint, bool bNotify = true);
    u8      GetNumVessels(){return m_Vessels.Count();}
    
        
        void LookForMountedVessels(bool bScanVessels = false);
        void RemoveAllVessels();
        
        
    Vessel* AddVessel(CascadeMountMessage::MediaType type, CascadeString name, CascadeString path);
    Vessel* AddVessel(Vessel* pVessel);
        // NOTE NOTE NOTE: AddVessel consumes the vessel passed into it --
        // it either adds it to the internal array, or if the vessel is
        // a duplicate (same mount point) as an existing vessel, the object
        // passed in is deleted.  DO NOT DELETE this vessel after adding it,
        // and be sure to check equivalency of the returned pointer with
        // the submitted pointer before using the submitted pointer (or just
        // reassign the pointer: myVessel = AddVessel( myVessel ); )
    bool RemoveVessel(CascadeString path);
    void ScanVessel(Vessel* pV);

    
    public: // virtual functions overridden from base classes
    virtual bool OnKeyDown(u32 nKey);
        // The Default OnKeyDown switches to the next item in the list.

    virtual void OnPaint(CascadeBitmap & bitmap);
        // If no bitmaps are set, the default implemetation will render the text alone.
                

    virtual bool OnNavKey(u32 nKey, CascadeWindow * & pProposedNewFocusWnd);
        // left and right switch through the choices, up and down leave the widget.

    virtual bool WillAcceptFocus(){return m_Vessels.Count() > 0;}

    private:
    enum {kVesselButtonYSpacing = 8, kVesselButtonTextSpacing = 8};

        CascadeString m_graphics_oem_selector;

    void AcquireGraphics();
    void ReleaseGraphics();
        
    
    bool    Scroll(); // Scrolls to make sure that the active vessel is on screen
    
    void    NotifyActiveVesselChanged();

    void    NotifyVesselWorkingDirChanged();
    
    static void BrowseDirectoryCallback( const CascadeString & inPath,
                                         CascadeDirBrowser::CallbackReason inReason,
                                         void * pClientData );
    CascadeTemplateArray<Vessel*> m_Vessels;
        CascadeSettings m_settings;
        
        bool m_bFullRepaint; // if this is true, repaint everything, otherwise just repaint
                                                // the ones that changed.
    //Vessel*                 m_vessels[MAX_VESSELS];

    u8                      m_nFirstVisibleVessel;  // Visible vessels are
                                                    // [m_vessels[m_nFirstVisibleVessel],  m_vessels[m_nFirstVisibleVessel + MAX_VISIBLE_VESSELS - 1]]
    u8                      m_nActiveVessel;         // the vessel that we are currently looking at
        u8                                              m_nPrevActive;                  // the vessel that was active before the current active vessel.
        
        CascadeWormhole m_vesselchangeWormhole;
        u32                             m_nVesselChangeMessageID;
        
        #define NUM_MEDIA_TYPES CascadeMountMessage::kNumMediaTypes
    CascadeBitmap* m_NormalBitmaps[CascadeMountMessage::kNumMediaTypes ];
    CascadeBitmap* m_HighlightBitmaps[CascadeMountMessage::kNumMediaTypes];
        CascadeBitmap* m_innerMoat;
        CascadeBitmap* m_outerMoat;
    CascadeBitmap* m_upArrow;
    CascadeBitmap* m_downArrow;

    CascadeFont m_font;

    bool m_bAcquireOnPaint;

    ActiveVesselChangeCallback * m_pVesselChangedCallback;
    ActiveVesselChangeCallback * m_pWorkingDirCallback;
    void * m_pVesselChangedClientData;
    void * m_pWorkingDirClientData;
        VesselInsertedCallback * m_pMountCallback;
        VesselRemovedCallback * m_pRemoveCallback;
    void * m_pMountClientData;
        void * m_pRemoveClientData;

    private:
    
        bool m_bRemoving;

private:
    class Slot
    {
    public:
        CascadePoint m_renderPoint;
        CascadePoint m_moatPoint;
        CascadeBitmap * m_pMoat;
    };
    Slot m_slots[MAX_VISIBLE_VESSELS];
};

#endif // #ifndef _ROKU_INCLUDE_CASCADE_WIDGETS_CASCADEVESSELPANEL_H

//  LOG
//  26-Aug-03   dwoodward   added ConvertEscapedOctalCharacters()
//  19-Sep-03   dsletten    added #defines for dir choose settings, m_settings
//  05-Nov-03   mjkobb      Moved Vessel class into its own file.
//  20-Oct-04   dwoodward   moved _VESSEL_PANEL_VESSELCHANGE_WORMHOLE_URL into CascadeVesselPanel.cpp
//  12-Nov-04   dwoodward   added m_slots for faster painting
//  08-Apr-05   dwoodward   made the vessel removed callback take a CascadeString &, not a string

---