llmediaplugins first step

1 files changed, 667 insertions, 0 deletions

diff --git a/linden/indra/newview/llpanelmediahud.cpp b/linden/indra/newview/llpanelmediahud.cpp
new file mode 100644
index 0000000..39c4b63
--- /dev/null
+++ b/linden/indra/newview/llpanelmediahud.cpp
@@ -0,0 +1,667 @@
+/** 
+ * @file llpanelmsgs.cpp
+ * @brief Message popup preferences panel
+ *
+ * $LicenseInfo:firstyear=2003&license=viewergpl$
+ * 
+ * Copyright (c) 2003-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+//LLPanelMediaHUD
+#include "llagent.h"
+#include "llparcel.h"
+#include "llpanel.h"
+#include "llselectmgr.h"
+#include "llrender.h"
+#include "lldrawable.h"
+#include "llviewerwindow.h"
+#include "lluictrlfactory.h"
+#include "llbutton.h"
+#include "llface.h"
+#include "llhudview.h"
+#include "lliconctrl.h"
+#include "lltoolpie.h"
+#include "llviewercamera.h"
+#include "llpanelmediahud.h"
+#include "llpluginclassmedia.h"
+#include "llviewercontrol.h"
+#include "llviewerparcelmgr.h"
+#include "llviewermedia.h"
+#include "llviewermediafocus.h"
+#include "llvovolume.h"
+#include "llweb.h"
+
+glh::matrix4f glh_get_current_modelview();
+glh::matrix4f glh_get_current_projection();
+
+const F32 ZOOM_NEAR_PADDING             = 1.0f;
+const F32 ZOOM_MEDIUM_PADDING   = 1.2f;
+const F32 ZOOM_FAR_PADDING              = 1.5f;
+
+//
+// LLPanelMediaHUD
+//
+
+LLPanelMediaHUD::LLPanelMediaHUD(viewer_media_t media_impl)
+ :      mMediaImpl(media_impl)
+{
+        mMediaFocus = false;
+        LLUICtrlFactory::getInstance()->buildPanel(this, "panel_media_hud.xml");
+        mMouseMoveTimer.reset();
+        mFadeTimer.stop();
+        mCurrentZoom = ZOOM_NONE;
+        mScrollState = SCROLL_NONE;
+
+        mPanelHandle.bind(this);
+}
+LLPanelMediaHUD::~LLPanelMediaHUD()
+{
+        mMediaImpl = NULL;
+}
+
+BOOL LLPanelMediaHUD::postBuild()
+{
+        LLButton* close_btn = getChild<LLButton>("close");
+        close_btn->setClickedCallback(onClickClose, this);
+
+        LLButton* back_btn = getChild<LLButton>("back");
+        back_btn->setClickedCallback(onClickBack, this);
+
+        LLButton* fwd_btn = getChild<LLButton>("fwd");
+        fwd_btn->setClickedCallback(onClickForward, this);
+
+        LLButton* home_btn = getChild<LLButton>("home");
+        home_btn->setClickedCallback(onClickHome, this);
+
+        LLButton* stop_btn = getChild<LLButton>("stop");
+        stop_btn->setClickedCallback(onClickStop, this);
+
+        LLButton* media_stop_btn = getChild<LLButton>("media_stop");
+        media_stop_btn->setClickedCallback(onClickStop, this);
+
+        LLButton* reload_btn = getChild<LLButton>("reload");
+        reload_btn->setClickedCallback(onClickReload, this);
+
+        LLButton* play_btn = getChild<LLButton>("play");
+        play_btn->setClickedCallback(onClickPlay, this);
+
+        LLButton* pause_btn = getChild<LLButton>("pause");
+        pause_btn->setClickedCallback(onClickPause, this);
+
+        LLButton* open_btn = getChild<LLButton>("new_window");
+        open_btn->setClickedCallback(onClickOpen, this);
+
+        LLButton* zoom_btn = getChild<LLButton>("zoom_frame");
+        zoom_btn->setClickedCallback(onClickZoom, this);
+
+        LLButton* open_btn_h = getChild<LLButton>("new_window_hover");
+        open_btn_h->setClickedCallback(onClickOpen, this);
+
+        LLButton* zoom_btn_h = getChild<LLButton>("zoom_frame_hover");
+        zoom_btn_h->setClickedCallback(onClickZoom, this);
+
+        LLButton* scroll_up_btn = getChild<LLButton>("scrollup");
+        scroll_up_btn->setClickedCallback(onScrollUp, this);
+        scroll_up_btn->setHeldDownCallback(onScrollUpHeld);
+        scroll_up_btn->setMouseUpCallback(onScrollStop);
+        LLButton* scroll_left_btn = getChild<LLButton>("scrollleft");
+        scroll_left_btn->setClickedCallback(onScrollLeft, this);
+        scroll_left_btn->setHeldDownCallback(onScrollLeftHeld);
+        scroll_left_btn->setMouseUpCallback(onScrollStop);
+        LLButton* scroll_right_btn = getChild<LLButton>("scrollright");
+        scroll_right_btn->setClickedCallback(onScrollRight, this);
+        scroll_right_btn->setHeldDownCallback(onScrollLeftHeld);
+        scroll_right_btn->setMouseUpCallback(onScrollStop);
+        LLButton* scroll_down_btn = getChild<LLButton>("scrolldown");
+        scroll_down_btn->setClickedCallback(onScrollDown, this);
+        scroll_down_btn->setHeldDownCallback(onScrollDownHeld);
+        scroll_down_btn->setMouseUpCallback(onScrollStop);
+
+        mMouseInactiveTime = gSavedSettings.getF32("MediaControlTimeout");
+        mControlFadeTime = gSavedSettings.getF32("MediaControlFadeTime");
+
+        mCurrentZoom = ZOOM_NONE;
+        // clicks on HUD buttons do not remove keyboard focus from media
+        setIsChrome(TRUE);
+        return TRUE;
+}
+
+void LLPanelMediaHUD::updateShape()
+{
+        const S32 MIN_HUD_WIDTH=200;
+        const S32 MIN_HUD_HEIGHT=120;
+
+        LLPluginClassMedia* media_plugin = NULL;
+        if(mMediaImpl.notNull() && mMediaImpl->hasMedia())
+        {
+                media_plugin = mMediaImpl->getMediaPlugin();
+        }
+
+        // Early out for no media plugin
+        if(media_plugin == NULL)
+        {
+                setVisible(FALSE);
+                return;
+        }
+
+        LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+
+        bool can_navigate = parcel->getMediaAllowNavigate();
+
+        // LLObjectSelectionHandle selection = LLViewerMediaFocus::getInstance()->getSelection();
+
+        LLSelectNode* nodep = mMediaFocus ? LLSelectMgr::getInstance()->getSelection()->getFirstNode() : LLSelectMgr::getInstance()->getHoverNode();
+        if(! nodep)
+        {
+                return;
+        }
+        setVisible(FALSE);
+        LLViewerObject* objectp = nodep->getObject();
+
+        if (objectp)
+        {
+
+                // Set the state of the buttons
+                LLButton* back_btn = getChild<LLButton>("back");
+                LLButton* fwd_btn = getChild<LLButton>("fwd");
+                LLButton* reload_btn = getChild<LLButton>("reload");
+                LLButton* play_btn = getChild<LLButton>("play");
+                LLButton* pause_btn = getChild<LLButton>("pause");
+                LLButton* stop_btn = getChild<LLButton>("stop");
+                LLButton* media_stop_btn = getChild<LLButton>("media_stop");
+                LLButton* home_btn = getChild<LLButton>("home");
+                LLButton* close_btn = getChild<LLButton>("close");
+                LLButton* open_btn = getChild<LLButton>("new_window");
+                LLPanel* media_focused_panel = getChild<LLPanel>("media_focused_controls");
+                LLPanel* media_hover_panel = getChild<LLPanel>("media_hover_controls");
+                back_btn->setVisible(true);
+                fwd_btn->setVisible(true);
+                reload_btn->setVisible(true);
+                stop_btn->setVisible(false);
+                home_btn->setVisible(true);
+                close_btn->setVisible(true);
+                open_btn->setVisible(true);
+
+
+                if(mMediaFocus)
+                {
+                        back_btn->setEnabled(mMediaImpl->canNavigateBack() && can_navigate);
+                        fwd_btn->setEnabled(mMediaImpl->canNavigateForward() && can_navigate);
+                        stop_btn->setEnabled(can_navigate);
+                        home_btn->setEnabled(can_navigate);
+                        LLPluginClassMediaOwner::EMediaStatus result = media_plugin->getStatus();
+
+                        if(media_plugin->pluginSupportsMediaTime())
+                        {
+                                reload_btn->setEnabled(FALSE);
+                                reload_btn->setVisible(FALSE);
+                                media_stop_btn->setVisible(TRUE);
+                                home_btn->setVisible(FALSE);
+                                back_btn->setEnabled(TRUE);
+                                fwd_btn->setEnabled(TRUE);
+                                switch(result)
+                                {
+                                case LLPluginClassMediaOwner::MEDIA_PLAYING:
+                                        play_btn->setEnabled(FALSE);
+                                        play_btn->setVisible(FALSE);
+                                        pause_btn->setEnabled(TRUE);
+                                        pause_btn->setVisible(TRUE);
+                                        media_stop_btn->setEnabled(TRUE);
+                                        break;
+                                case LLPluginClassMediaOwner::MEDIA_PAUSED:
+                                default:
+                                        pause_btn->setEnabled(FALSE);
+                                        pause_btn->setVisible(FALSE);
+                                        play_btn->setEnabled(TRUE);
+                                        play_btn->setVisible(TRUE);
+                                        media_stop_btn->setEnabled(FALSE);
+                                        break;
+                                }
+                        }
+                        else
+                        {
+                                play_btn->setVisible(FALSE);
+                                pause_btn->setVisible(FALSE);
+                                media_stop_btn->setVisible(FALSE);
+                                if(result == LLPluginClassMediaOwner::MEDIA_LOADING)
+                                {
+                                        reload_btn->setEnabled(FALSE);
+                                        reload_btn->setVisible(FALSE);
+                                        stop_btn->setEnabled(TRUE);
+                                        stop_btn->setVisible(TRUE);
+                                }
+                                else
+                                {
+                                        reload_btn->setEnabled(TRUE);
+                                        reload_btn->setVisible(TRUE);
+                                        stop_btn->setEnabled(FALSE);
+                                        stop_btn->setVisible(FALSE);
+                                }
+                        }
+                }
+                media_focused_panel->setVisible(mMediaFocus);
+                media_hover_panel->setVisible(!mMediaFocus);
+
+                if(media_plugin == NULL)
+                // Handle Scrolling
+                switch (mScrollState) 
+                {
+                case SCROLL_UP:
+                        media_plugin->scrollEvent(0, -1, MASK_NONE);
+                        break;
+                case SCROLL_DOWN:
+                        media_plugin->scrollEvent(0, 1, MASK_NONE);
+                        break;
+                case SCROLL_LEFT:
+                        mMediaImpl->handleKeyHere(KEY_LEFT, MASK_NONE);
+                        break;
+                case SCROLL_RIGHT:
+                        mMediaImpl->handleKeyHere(KEY_RIGHT, MASK_NONE);
+                        break;
+                case SCROLL_NONE:
+                default:
+                        break;
+                }
+                LLBBox screen_bbox;
+                setVisible(TRUE);
+                glh::matrix4f mat = glh_get_current_projection()*glh_get_current_modelview();
+                std::vector<LLVector3>::iterator vert_it;
+                std::vector<LLVector3>::iterator vert_end;
+                std::vector<LLVector3> vect_face;
+
+                LLVolume* volume = objectp->getVolume();
+
+                if (volume)
+                {
+                        const LLVolumeFace& vf = volume->getVolumeFace(nodep->getLastSelectedTE());
+
+                        const LLVector3* ext = vf.mExtents;
+
+                        LLVector3 center = (ext[0]+ext[1])*0.5f;
+                        LLVector3 size = (ext[1]-ext[0])*0.5f;
+                        LLVector3 vert[] =
+                        {
+                                center + size.scaledVec(LLVector3(1,1,1)),
+                                center + size.scaledVec(LLVector3(-1,1,1)),
+                                center + size.scaledVec(LLVector3(1,-1,1)),
+                                center + size.scaledVec(LLVector3(-1,-1,1)),
+                                center + size.scaledVec(LLVector3(1,1,-1)),
+                                center + size.scaledVec(LLVector3(-1,1,-1)),
+                                center + size.scaledVec(LLVector3(1,-1,-1)),
+                                center + size.scaledVec(LLVector3(-1,-1,-1)),
+                        };
+
+                        LLVOVolume* vo = (LLVOVolume*) objectp;
+
+                        for (U32 i = 0; i < 8; i++)
+                        {
+                                vect_face.push_back(vo->volumePositionToAgent(vert[i]));        
+                        }
+                }
+                vert_it = vect_face.begin();
+                vert_end = vect_face.end();
+
+                LLVector3 min = LLVector3(1,1,1);
+                LLVector3 max = LLVector3(-1,-1,-1);
+                for(; vert_it != vert_end; ++vert_it)
+                {
+                        // project silhouette vertices into screen space
+                        glh::vec3f screen_vert = glh::vec3f(vert_it->mV); 
+                        mat.mult_matrix_vec(screen_vert);
+
+                        // add to screenspace bounding box
+                        update_min_max(min, max, LLVector3(screen_vert.v));
+                }
+
+                LLCoordGL screen_min;
+                screen_min.mX = llround((F32)gViewerWindow->getWindowWidth() * (min.mV[VX] + 1.f) * 0.5f);
+                screen_min.mY = llround((F32)gViewerWindow->getWindowHeight() * (min.mV[VY] + 1.f) * 0.5f);
+
+                LLCoordGL screen_max;
+                screen_max.mX = llround((F32)gViewerWindow->getWindowWidth() * (max.mV[VX] + 1.f) * 0.5f);
+                screen_max.mY = llround((F32)gViewerWindow->getWindowHeight() * (max.mV[VY] + 1.f) * 0.5f);
+
+                // grow panel so that screenspace bounding box fits inside "media_region" element of HUD
+                LLRect media_hud_rect;
+                getParent()->screenRectToLocal(LLRect(screen_min.mX, screen_max.mY, screen_max.mX, screen_min.mY), &media_hud_rect);
+                LLView* media_region = getChild<LLView>("media_region");
+                media_hud_rect.mLeft -= media_region->getRect().mLeft;
+                media_hud_rect.mBottom -= media_region->getRect().mBottom;
+                media_hud_rect.mTop += getRect().getHeight() - media_region->getRect().mTop;
+                media_hud_rect.mRight += getRect().getWidth() - media_region->getRect().mRight;
+
+
+                LLRect old_hud_rect = media_hud_rect;
+                // keep all parts of HUD on-screen
+                media_hud_rect.intersectWith(getParent()->getLocalRect());
+
+                // If we had to clip the rect, don't display the border
+                childSetVisible("bg_image", false);
+
+                // clamp to minimum size, keeping centered
+                media_hud_rect.setCenterAndSize(media_hud_rect.getCenterX(), media_hud_rect.getCenterY(),
+                        llmax(MIN_HUD_WIDTH, media_hud_rect.getWidth()), llmax(MIN_HUD_HEIGHT, media_hud_rect.getHeight()));
+
+                userSetShape(media_hud_rect);
+
+                // Test mouse position to see if the cursor is stationary
+                LLCoordWindow cursor_pos_window;
+                getWindow()->getCursorPosition(&cursor_pos_window);
+
+                // If last pos is not equal to current pos, the mouse has moved
+                // We need to reset the timer, and make sure the panel is visible
+                if(cursor_pos_window.mX != mLastCursorPos.mX ||
+                        cursor_pos_window.mY != mLastCursorPos.mY ||
+                        mScrollState != SCROLL_NONE)
+                {
+                        mMouseMoveTimer.start();
+                        mLastCursorPos = cursor_pos_window;
+                }
+                
+                // Mouse has been stationary, but not for long enough to fade the UI
+                if(mMouseMoveTimer.getElapsedTimeF32() < mMouseInactiveTime)
+                {
+                        // If we have started fading, reset the alpha values
+                        if(mFadeTimer.getStarted())
+                        {
+                                F32 alpha = 1.0f;
+                                setAlpha(alpha);
+                                mFadeTimer.stop();
+                        }
+                }
+                // If we need to start fading the UI (and we have not already started)
+                else if(! mFadeTimer.getStarted())
+                {
+                        mFadeTimer.reset();
+                        mFadeTimer.start();
+                }
+        }
+}
+/*virtual*/
+void LLPanelMediaHUD::draw()
+{
+        if(mFadeTimer.getStarted())
+        {
+                if(mFadeTimer.getElapsedTimeF32() >= mControlFadeTime)
+                {
+                        setVisible(FALSE);
+                }
+                else
+                {
+                        F32 time = mFadeTimer.getElapsedTimeF32();
+                        F32 alpha = llmax(lerp(1.0, 0.0, time / mControlFadeTime), 0.0f);
+                        setAlpha(alpha);
+                }
+        }
+        LLPanel::draw();
+}
+void LLPanelMediaHUD::setAlpha(F32 alpha)
+{
+        LLViewQuery query;
+
+        LLView* query_view = mMediaFocus ? getChildView("media_focused_controls") : getChildView("media_hover_controls");
+        child_list_t children = query(query_view);
+        for (child_list_iter_t child_iter = children.begin();
+                child_iter != children.end(); ++child_iter)
+        {
+                LLUICtrl* ctrl = dynamic_cast<LLUICtrl*>(*child_iter);
+                if (ctrl)
+                        ctrl->setAlpha(alpha);
+        }
+
+        LLPanel::setAlpha(alpha);
+}
+BOOL LLPanelMediaHUD::handleScrollWheel(S32 x, S32 y, S32 clicks)
+{
+        return LLViewerMediaFocus::getInstance()->handleScrollWheel(x, y, clicks);
+}
+bool LLPanelMediaHUD::isMouseOver()
+{
+        if( ! getVisible() )
+        {
+                return false;
+        }
+        LLRect screen_rect;
+        LLCoordWindow cursor_pos_window;
+        getWindow()->getCursorPosition(&cursor_pos_window);
+
+        localRectToScreen(getLocalRect(), &screen_rect);
+        // screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &local_mouse_x, &local_mouse_y);
+
+        if(screen_rect.pointInRect(cursor_pos_window.mX, cursor_pos_window.mY))
+        {
+                return true;
+        }
+        return false;
+}
+
+//static
+void LLPanelMediaHUD::onClickClose(void* user_data)
+{
+        LLViewerMediaFocus::getInstance()->setFocusFace(FALSE, NULL, 0, NULL);
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mCurrentZoom != ZOOM_NONE)
+        {
+                // gAgent.setFocusOnAvatar(TRUE, ANIMATE);
+                this_panel->mCurrentZoom = ZOOM_NONE;
+        }
+        this_panel->setVisible(FALSE);
+
+}
+
+//static
+void LLPanelMediaHUD::onClickBack(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if (this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                if(this_panel->mMediaImpl->getMediaPlugin()->pluginSupportsMediaTime())
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->start(-2.0);
+                }
+                else
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->browse_back();
+                }
+
+        }
+}
+//static
+void LLPanelMediaHUD::onClickForward(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if (this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                if(this_panel->mMediaImpl->getMediaPlugin()->pluginSupportsMediaTime())
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->start(2.0);
+                }
+                else
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->browse_forward();
+                }
+        }
+}
+//static
+void LLPanelMediaHUD::onClickHome(void* user_data)
+{
+        //LLViewerMedia::navigateHome();
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull())
+        {
+                this_panel->mMediaImpl->navigateHome();
+        }
+}
+//static
+void LLPanelMediaHUD::onClickOpen(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull())
+        {
+                LLWeb::loadURL(this_panel->mMediaImpl->getMediaURL());
+        }       
+}
+//static
+void LLPanelMediaHUD::onClickReload(void* user_data)
+{
+        //LLViewerMedia::navigateHome();
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        LLViewerObject* objectp = LLSelectMgr::getInstance()->getSelection()->getFirstObject();
+        if(objectp && this_panel->mMediaImpl.notNull())
+        {
+                this_panel->mMediaImpl->navigateTo(objectp->getMediaURL());
+        }
+}
+//static
+void LLPanelMediaHUD::onClickPlay(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if (this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                this_panel->mMediaImpl->getMediaPlugin()->start();
+        }
+}
+//static
+void LLPanelMediaHUD::onClickPause(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if (this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                this_panel->mMediaImpl->getMediaPlugin()->pause();
+        }
+}
+//static 
+void LLPanelMediaHUD::onClickStop(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if (this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                if(this_panel->mMediaImpl->getMediaPlugin()->pluginSupportsMediaTime())
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->stop();
+                }
+                else
+                {
+                        this_panel->mMediaImpl->getMediaPlugin()->browse_stop();
+                }
+        }
+}
+//static 
+void LLPanelMediaHUD::onClickZoom(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->nextZoomLevel();
+}
+void LLPanelMediaHUD::nextZoomLevel()
+{
+        F32 zoom_padding = 0.0f;
+        S32 last_zoom_level = (S32)mCurrentZoom;
+        mCurrentZoom = (EZoomLevel)((last_zoom_level + 1) % (S32)ZOOM_END);
+
+        switch (mCurrentZoom)
+        {
+        case ZOOM_NONE:
+                {
+                        gAgent.setFocusOnAvatar(TRUE, ANIMATE);
+                        break;
+                }
+        case ZOOM_MEDIUM:
+                {
+                        zoom_padding = ZOOM_MEDIUM_PADDING;
+                        break;
+                }
+        default:
+                {
+                        gAgent.setFocusOnAvatar(TRUE, ANIMATE);
+                        break;
+                }
+        }
+
+        if (zoom_padding > 0.0f)                
+                LLViewerMediaFocus::getInstance()->setCameraZoom(zoom_padding);
+}
+void LLPanelMediaHUD::onScrollUp(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                this_panel->mMediaImpl->getMediaPlugin()->scrollEvent(0, -1, MASK_NONE);
+        }
+}
+void LLPanelMediaHUD::onScrollUpHeld(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->mScrollState = SCROLL_UP;
+}
+void LLPanelMediaHUD::onScrollRight(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull())
+        {
+                this_panel->mMediaImpl->handleKeyHere(KEY_RIGHT, MASK_NONE);
+        }
+}
+void LLPanelMediaHUD::onScrollRightHeld(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->mScrollState = SCROLL_RIGHT;
+}
+
+void LLPanelMediaHUD::onScrollLeft(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull())
+        {
+                this_panel->mMediaImpl->handleKeyHere(KEY_LEFT, MASK_NONE);
+        }
+}
+void LLPanelMediaHUD::onScrollLeftHeld(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->mScrollState = SCROLL_LEFT;
+}
+
+void LLPanelMediaHUD::onScrollDown(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        if(this_panel->mMediaImpl.notNull() && this_panel->mMediaImpl->hasMedia())
+        {
+                this_panel->mMediaImpl->getMediaPlugin()->scrollEvent(0, 1, MASK_NONE);
+        }
+}
+void LLPanelMediaHUD::onScrollDownHeld(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->mScrollState = SCROLL_DOWN;
+}
+
+void LLPanelMediaHUD::onScrollStop(void* user_data)
+{
+        LLPanelMediaHUD* this_panel = static_cast<LLPanelMediaHUD*> (user_data);
+        this_panel->mScrollState = SCROLL_NONE;
+}