SO3Engine/SO3Renderer/SO3Widget.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2010 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "../SO3SceneGraph/SO3Scene.h"
#include "SO3Widget.h"
#include "SO3WidgetManager.h"
#include <OgreBitwise.h>

namespace SO3
{

SWidget::SWidget() : SData(""), isOverlayed(false), is2DRect(false)
{
  // Forbiden, private constructor
}

SWidget::SWidget(SScene* targetScene, std::string widgetName, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, SViewPort* targetViewport, unsigned int widgetZOrder, std::string widgetType) : SData(widgetName), isOverlayed(true), is2DRect(false)
{
  StandardConstructor(targetScene, xPos, yPos, widgetWidth, widgetHeight, widgetZOrder, targetViewport, widgetType);
  CreateTexture();
  CreateMaterial();
  CreateOverlay();
}

SWidget::SWidget(SScene* targetScene, std::string widgetName, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, SViewPort* targetViewport, std::string widgetType) : SData(widgetName), isOverlayed(false), is2DRect(true)
{
  StandardConstructor(targetScene, xPos, yPos, widgetWidth, widgetHeight, 0, targetViewport, widgetType);
  CreateTexture();
  CreateMaterial();
  Create2D();
}

SWidget::SWidget(SScene* targetScene, std::string widgetName, unsigned short widgetWidth, unsigned short widgetHeight, SMaterial* targetMaterial, unsigned short targetTechnique, unsigned short targetPass, unsigned short targetTextureUnit, std::string widgetType) : SData(widgetName), isOverlayed(false), is2DRect(false)
{
  StandardConstructor(targetScene, 0, 0, widgetWidth, widgetHeight, 0, 0, widgetType);

  // Let the material know that a widget will modify it's internal data.
  // Warning, an exception can be fired here.
  originalMaterial = targetMaterial;
  //if (targetMaterial->GetAssociatedWidget() == 0)
  targetMaterial->SetAssociatedWidget(this);

  // Warning, an exception can be fired here too.  
  Ogre::MaterialPtr ogreOriginalMaterial = targetMaterial->getOgreMaterialPointer();
  originalMaterialPass = ogreOriginalMaterial->getTechnique(targetTechnique)->getPass(targetPass);
  originalTextureUnit = originalMaterialPass->getTextureUnitState(targetTextureUnit);
  originalTextureUnitMinFiltering = originalTextureUnit->getTextureFiltering(Ogre::FT_MIN);
  originalTextureUnitMagFiltering = originalTextureUnit->getTextureFiltering(Ogre::FT_MAG);
  originalTextureUnitMipFiltering = originalTextureUnit->getTextureFiltering(Ogre::FT_MIP);
  originalTextureUnitBlendMode = originalTextureUnit->getAlphaBlendMode();


  // Store the original texture name
  originalTextureName = originalTextureUnit->getTextureName();

  originalSceneBlendFactorSource = originalMaterialPass->getSourceBlendFactor();
  originalSceneBlendFactorDest = originalMaterialPass->getDestBlendFactor();
  originalMaterialDepthCheck = originalMaterialPass->getDepthCheckEnabled();
  originalMaterialDepthWrite = originalMaterialPass->getDepthWriteEnabled();

  // Create texture AFTER storing original material and texture informations
  CreateTexture();
}

void SWidget::StandardConstructor(SScene* targetScene, int xPos, int yPos, unsigned short widgetWidth, unsigned short widgetHeight, unsigned int widgetZOrder, SViewPort* targetViewport, std::string widgetType)
{
  // Default Init
  type                  = widgetType;
  leftPos               = xPos;
  topPos                = yPos;
  width                 = widgetWidth;
  height                = widgetHeight;
  scene                 = targetScene;
  viewport              = targetViewport;
  renderingTexture.setNull();
  renderingTextureUnit  = 0;
  textureWidth          = 0;
  textureHeight         = 0;
  baseResourceName      = std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/Widgets/"+widgetType;
  compensateNPOT        = false;
  originalTextureUnit   = 0;
  originalTextureName   = "";
  originalMaterialPass  = 0;
  topOnFocus            = false;
  isPriorized           = false;
  originalMaterial      = 0;
  mouseIsOver           = false;
  opacity               = 1.0f;
  isTransparent         = false;
  mouseEnable           = true;
  keyboardEnable        = true;
  forceRenderingUpdate  = false;
  transparentIgnorePixels = isOverlayed;
  transparentTresholdColor = (transparentIgnorePixels) ? 0.04f : 0.0f;

  // 2D rect stuff
  ogre2dRect = 0;
  ogre2dNode = 0;

  // Overlay stuff
  zOrder = widgetZOrder;
  ogreOverlay = 0;
  ogreOverlayPanel = 0;
  ogreOverlayMaterial.setNull();
}

SWidget::~SWidget()
{
  // For overlayed widget only
  if (isOverlayed)
  {
    DestroyOverlay();
    DestroyMaterial();
  }
  else if (is2DRect)
  {
    Destroy2D();
    DestroyMaterial();
  }
  else
  {
    // Reset the original texture name if the widget was created on an existing material
    if(originalTextureUnit != 0)
    {
      originalMaterialPass->setSceneBlending(originalSceneBlendFactorSource, originalSceneBlendFactorDest);
      originalMaterialPass->setDepthCheckEnabled(originalMaterialDepthCheck);
      originalMaterialPass->setDepthWriteEnabled(originalMaterialDepthWrite);
      originalTextureUnit->setTextureFiltering(originalTextureUnitMinFiltering, originalTextureUnitMagFiltering, originalTextureUnitMipFiltering);
      originalTextureUnit->setAlphaOperation(originalTextureUnitBlendMode.operation, originalTextureUnitBlendMode.source1, originalTextureUnitBlendMode.source2, originalTextureUnitBlendMode.alphaArg1, originalTextureUnitBlendMode.alphaArg2, originalTextureUnitBlendMode.factor);
      originalTextureUnit->setTextureName(originalTextureName);
    }
  }

  // Free rendering texture
  DestroyTexture();

  if (isOverlayed)
    SWidgetManager::getSingleton().UpdateWidgetsZOrder(); // Recalculate zOrder of all widgets without this one.
  else if (!is2DRect)
    originalMaterial->SetAssociatedWidget(0);             // Remove reference to this widget of the material
}

SScene* SWidget::GetParentScene()
{
  return scene;
}

std::string SWidget::GetType()
{
  return type;
}

bool SWidget::IsCompensateNPOT() const
{
  return compensateNPOT;
}

unsigned short SWidget::GetWidth()
{
  return width;
}

unsigned short SWidget::GetHeight()
{
  return height;
}

SPoint<unsigned short> SWidget::GetSize()
{
  return SPoint<unsigned short>(width, height);
}

void SWidget::SetSize(unsigned short newWidth, unsigned short newHeight)
{
  SetSize(SPoint<unsigned short>(newWidth, newHeight));
}

void SWidget::SetSize(SPoint<unsigned short> newSize)
{
  width = newSize.x;
  height = newSize.y;
  SetSizeImpl(width, height);
  CreateTexture();

  if(ogreOverlay != 0)
    ogreOverlayPanel->setDimensions(width, height);
  
  if(ogre2dRect != 0)
  {
    Ogre::Real wcoef = 2.0f / ((viewport->GetWidthPixels() <= 0) ? 1.0f : viewport->GetWidthPixels());
    Ogre::Real hcoef = 2.0f / ((viewport->GetHeightPixels() <= 0) ? 1.0f : viewport->GetHeightPixels());
    Ogre::Real w = wcoef * width;
    Ogre::Real h = hcoef * height;
    Ogre::Real l = (wcoef * leftPos) - 1.0f;
    Ogre::Real t = 1.0f - (hcoef * topPos);
    Ogre::Real r = ((wcoef * leftPos) + w) - 1.0f;
    Ogre::Real b = 1.0f - ((hcoef * topPos) + h);
    ogre2dRect->setCorners(l, t, r, b);
  };
}

SPoint<int> SWidget::GetPosition()
{
  if((ogreOverlay != 0) || (ogre2dRect != 0))
    return SPoint<int>(leftPos, topPos);
  else
    return SPoint<int>(0, 0);
}

void SWidget::SetPosition(int xPos, int yPos)
{
  SetPosition(SPoint<int>(xPos, yPos));
}

void SWidget::SetPosition(const SPoint<int>& newPosition)
{
  if(ogreOverlay != 0)
  {
    leftPos = newPosition.x;
    topPos = newPosition.y;
    ogreOverlayPanel->setPosition(static_cast<Ogre::Real> (leftPos), static_cast<Ogre::Real> (topPos));
  }

  if(ogre2dRect != 0)
  {
    leftPos = newPosition.x;
    topPos = newPosition.y;
    Ogre::Real wcoef = 2.0f / ((viewport->GetWidthPixels() <= 0) ? 1.0f : viewport->GetWidthPixels());
    Ogre::Real hcoef = 2.0f / ((viewport->GetHeightPixels() <= 0) ? 1.0f : viewport->GetHeightPixels());
    Ogre::Real w = wcoef * width;
    Ogre::Real h = hcoef * height;
    Ogre::Real l = (wcoef * leftPos) - 1.0f;
    Ogre::Real t = 1.0f - (hcoef * topPos);
    Ogre::Real r = ((wcoef * leftPos) + w) - 1.0f;
    Ogre::Real b = 1.0f - ((hcoef * topPos) + h);
    ogre2dRect->setCorners(l, t, r, b);
  }
}

void SWidget::Move(const SPoint<int>& relativeMove)
{
  // Move the widget
  SetPosition(SPoint<int>(leftPos + relativeMove.x, topPos + relativeMove.y));
}

void SWidget::SetZOrder(unsigned short newWidgetOrder)
{
  zOrder = newWidgetOrder;

  // Update other widgets if needed.
  if(isOverlayed)
    SWidgetManager::getSingleton().UpdateWidgetsZOrder();
}

unsigned short SWidget::GetZOrder()
{
  return zOrder;
}

void SWidget::CreateTexture()
{
  // Check input data.
  assert((width!=0)&&(height!=0));

  // Erase existing texture (texture reset in case of re-creation).
  DestroyTexture();

  // Check if size is pow2
  if(!Ogre::Bitwise::isPO2(width) || !Ogre::Bitwise::isPO2(height))
  {
    Ogre::RenderSystem* ogreRenderSystem = Ogre::Root::getSingleton().getRenderSystem();
    if((!ogreRenderSystem->getCapabilities()->hasCapability(Ogre::RSC_NON_POWER_OF_2_TEXTURES)) || (ogreRenderSystem->getCapabilities()->getNonPOW2TexturesLimited()))
      compensateNPOT = true;
  }

  if(compensateNPOT)
  {
          textureWidth = Ogre::Bitwise::firstPO2From(width);
          textureHeight = Ogre::Bitwise::firstPO2From(height);
  }
  else
  {
    textureWidth = width;
    textureHeight = height;
  }

  // Create the texture
  try
  {
    renderingTexture = Ogre::TextureManager::getSingleton().createManual(baseResourceName+"/Texture/"+name, baseResourceName, Ogre::TEX_TYPE_2D, textureWidth, textureHeight, 0, Ogre::PF_BYTE_BGRA, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE, this);
  }
  catch (Ogre::Exception &e)
  {
          Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("An exception has occurred: "+ e.getDescription());
          renderingTexture.setNull();
  }

  // Initialise pixel buffer
  Ogre::HardwarePixelBufferSharedPtr pixelBuffer = renderingTexture->getBuffer();
  pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
  const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock();
  unsigned int textureDepth = Ogre::PixelUtil::getNumElemBytes(pixelBox.format);
  unsigned int texturePitch = (pixelBox.rowPitch*textureDepth);
  Ogre::uint8* pDest = static_cast<Ogre::uint8*>(pixelBox.data);
  memset(pDest, 0, textureHeight*texturePitch);
  pixelBuffer->unlock();

  // Apply on existing material
  if (originalTextureUnit != 0)
  {
    originalTextureUnit->setTextureName(baseResourceName+"/Texture/"+SWidget::name);
    renderingTextureUnit = originalTextureUnit;
  }
  else
  {
    if(!ogreOverlayMaterial.isNull())
      ogreOverlayMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(renderingTexture->getName());
  }
}

void SWidget::DestroyTexture()
{
  // Destroy internal rendering texture
  if (!renderingTexture.isNull())
  {
    // Tell the texture manager that we want to unload the texture, and set the shared pointer to null ask for texture total destruction.
    Ogre::TextureManager::getSingleton().remove(renderingTexture->getHandle());
    renderingTexture.setNull();
  }
}

void SWidget::CreateOverlay()
{
  assert(!ogreOverlayMaterial.isNull());

  // Erase existing panels and overlays (reset in case of re-creation).
  DestroyOverlay();

  // Create overlay.
  ogreOverlayPanel = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", baseResourceName +"/Overlays/Panels/"+ name));
        ogreOverlayPanel->setMetricsMode(Ogre::GMM_PIXELS);
  ogreOverlayPanel->setMaterialName(ogreOverlayMaterial->getName());
        ogreOverlayPanel->setDimensions(width, height);

        ogreOverlay = Ogre::OverlayManager::getSingleton().create(baseResourceName +"/Overlays/"+ name);
        ogreOverlay->add2D(ogreOverlayPanel);

  // Set the material on the overlay
  //if(compensateNPOT)
  //  ogreOverlayPanel->setUV(0, 0, (Ogre::Real)width/(Ogre::Real)textureWidth, (Ogre::Real)height/(Ogre::Real)textureHeight);

  SetPosition(SPoint<int>(leftPos, topPos));
        ogreOverlay->show();
}

void SWidget::DestroyOverlay()
{
  if(ogreOverlayPanel != 0)
  {
    Ogre::OverlayManager::getSingleton().destroyOverlayElement(ogreOverlayPanel);
    ogreOverlayPanel = 0;
  }

  if(ogreOverlay != 0)
  {
    Ogre::OverlayManager::getSingleton().destroy(ogreOverlay);
    ogreOverlay = 0;
  }
}

void SWidget::Create2D()
{
  assert(!ogreOverlayMaterial.isNull());

  // Erase existing 2D rect (reset in case of re-creation).
  Destroy2D();

  // Create overlay.
  ogre2dRect = new Ogre::Rectangle2D(true);
  SetPosition(SPoint<int>(leftPos, topPos));
  ogre2dRect->setMaterial(ogreOverlayMaterial->getName());

  // Render the background before everything else
  ogre2dRect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);

  // Use infinite AAB to always stay visible
  Ogre::AxisAlignedBox aabInf;
  aabInf.setInfinite();
  ogre2dRect->setBoundingBox(aabInf);
  
  // Set the material on the overlay
  /*if(compensateNPOT)
    ogre2dRect->setUVs(Ogre::Vector2(0, 0), Ogre::Vector2(0, (Ogre::Real)height/(Ogre::Real)textureHeight), Ogre::Vector2((Ogre::Real)width/(Ogre::Real)textureWidth, 0), Ogre::Vector2((Ogre::Real)width/(Ogre::Real)textureWidth, (Ogre::Real)height/(Ogre::Real)textureHeight));
  */

  // Attach background to the scene
  ogre2dNode = scene->GetOgreScenePointer()->getRootSceneNode()->createChildSceneNode(baseResourceName +"/Background/"+ name);
  ogre2dNode->attachObject(ogre2dRect);
}

void SWidget::Destroy2D()
{
  if(ogre2dRect != 0)
  {
    ogre2dRect->detachFromParent();
    scene->GetOgreScenePointer()->getRootSceneNode()->removeChild(ogre2dNode);
    scene->GetOgreScenePointer()->destroySceneNode(ogre2dNode);
    delete(ogre2dRect);
    ogre2dRect = 0;
    ogre2dNode = 0;
  }
}

void SWidget::CreateMaterial()
{
  assert((isOverlayed == true) || (is2DRect == true));

  // Erase existing material (reset in case of re-creation).
  DestroyMaterial();

  // Create the material that will be use by the overlay panel
  ogreOverlayMaterial = Ogre::MaterialManager::getSingleton().create(baseResourceName +"/Overlays/Panels/Materials/"+ name, baseResourceName);
  Ogre::Pass* matPass = ogreOverlayMaterial->getTechnique(0)->getPass(0);
  renderingTextureUnit = matPass->createTextureUnitState(renderingTexture->getName());
  
  if (is2DRect)
  {
    matPass->setDepthCheckEnabled(false);
    matPass->setDepthWriteEnabled(false);
    matPass->setLightingEnabled(false);
  }

  ApplyMaterialParameters(matPass, renderingTextureUnit);
}
    
void SWidget::DestroyMaterial()
{
  if (!ogreOverlayMaterial.isNull())
  {
    // Tell the material manager that we want to unload the material, and set the shared pointer to null ask for material total destruction.
    Ogre::MaterialManager::getSingleton().remove(ogreOverlayMaterial->getHandle());
    ogreOverlayMaterial.setNull();
    renderingTextureUnit = 0;
  }
}

void SWidget::ApplyMaterialParameters(Ogre::Pass* materialPassToModify, Ogre::TextureUnitState* materialTextureUnitToModify)
{
  assert((materialPassToModify != 0) && (materialTextureUnitToModify != 0));
  if ((isTransparent || (opacity != 1.0f)) && ((materialPassToModify->getTextureUnitStateIndex(materialTextureUnitToModify) == 0) || (isOverlayed) || (is2DRect)))
  {
    materialPassToModify->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
          materialPassToModify->setDepthWriteEnabled(false);
  }
  else
  {
    materialPassToModify->setSceneBlending((isTransparent || (opacity != 1.0f)) ? Ogre::SBT_TRANSPARENT_ALPHA : Ogre::SBT_REPLACE);

    if (!isTransparent && (opacity == 1.0f) && (!is2DRect))
      if (materialPassToModify->getTextureUnitStateIndex(materialTextureUnitToModify) == 0)
              materialPassToModify->setDepthWriteEnabled(true);
  }

  if (!isOverlayed)
    materialTextureUnitToModify->setTextureFiltering(Ogre::FO_LINEAR , Ogre::FO_LINEAR , Ogre::FO_LINEAR);
  else
          materialTextureUnitToModify->setTextureFiltering(Ogre::FO_NONE, Ogre::FO_NONE, Ogre::FO_NONE);

  if(opacity != 1.0f)
    renderingTextureUnit->setAlphaOperation(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_MANUAL, 1, opacity);
  else
    renderingTextureUnit->setAlphaOperation(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
}

void SWidget::loadResource(Ogre::Resource* resource)
{
  Ogre::Texture* tex = static_cast<Ogre::Texture*>(resource);
  tex->setTextureType(Ogre::TEX_TYPE_2D);
  tex->setWidth(textureWidth);
  tex->setHeight(textureHeight);
  tex->setNumMipmaps(0);
  tex->setFormat(Ogre::PF_BYTE_BGRA);
  tex->setUsage(Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
  tex->createInternalResources();

  forceRenderingUpdate = true;
}

void SWidget::_SetOgreOverlayZOrder(unsigned short overlayZOrder)
{
  assert(ogreOverlay != 0);
  ogreOverlay->setZOrder(overlayZOrder);
}

void SWidget::SetTopOnFocus(bool enableWidgetTopOnFocus)
{
  topOnFocus = enableWidgetTopOnFocus;
}

bool SWidget::GetTopOnFocus()
{
  return topOnFocus;
}

void SWidget::SetForeground(bool enableWidgetForeground)
{
  isPriorized = enableWidgetForeground;
  SWidgetManager::getSingleton().UpdateWidgetsZOrder();
}

bool SWidget::GetForeground()
{
  return isPriorized;
}

void SWidget::TakeFocus()
{
  SWidgetManager::getSingleton().UpdateFocusedWidget(this);
}

bool SWidget::HasFocus()
{
  if(SWidgetManager::getSingleton().GetFocusedWidget() == this)
    return true;
  else
    return false;
}

bool SWidget::GetMouseOver()
{
  return mouseIsOver;
}

void SWidget::SetOpacity(float widgetOpacity)
{
  // Bound opacity values between 0 and 1.
  if(widgetOpacity > 1)
    widgetOpacity = 1;
  else if(widgetOpacity < 0) 
    widgetOpacity = 0;

  // Set opacity on texture unit.
  opacity = widgetOpacity;

  if((isOverlayed) || (is2DRect))
    ApplyMaterialParameters(ogreOverlayMaterial->getTechnique(0)->getPass(0), renderingTextureUnit);
  else
    ApplyMaterialParameters(originalMaterialPass, renderingTextureUnit);
}

float SWidget::GetOpacity()
{
  return opacity;
}

void SWidget::Show(bool fade, unsigned short fadeDurationMS)
{
  if(ogreOverlay != 0)
    ogreOverlay->show();

  if(ogre2dRect != 0)
    ogre2dRect->setVisible(true);
}

void SWidget::Hide(bool fade, unsigned short fadeDurationMS)
{
  if(ogreOverlay != 0)
    ogreOverlay->hide();

  if(ogre2dRect != 0)
    ogre2dRect->setVisible(false);
  // TODO if no overlayed, resume textureUnit to the original tu.
}

bool SWidget::GetVisible()
{
  if(ogreOverlay != 0)
    return ogreOverlay->isVisible();
  else if(ogre2dRect != 0)
    return ogre2dRect->isVisible();
  else  
    return true;
}

void SWidget::SetTransparency(bool enableTransparency)
{
  if(enableTransparency != isTransparent)
  {
    isTransparent = enableTransparency;
    SetTransparencyImpl(isTransparent);

    if((isOverlayed) || (is2DRect))
      ApplyMaterialParameters(ogreOverlayMaterial->getTechnique(0)->getPass(0), renderingTextureUnit);
    else
      ApplyMaterialParameters(originalMaterialPass, renderingTextureUnit);
  }
}

bool SWidget::GetTransparency()
{
  return isTransparent;
}

void SWidget::SetKeyboardEnable(bool enableKeyboardOnWidget)
{
  keyboardEnable = enableKeyboardOnWidget;
  SetKeyboardEnableImpl(enableKeyboardOnWidget);
}

bool SWidget::GetKeyboardEnable()
{
  return keyboardEnable;
}

void SWidget::SetMouseEnable(bool enableMouseOnWidget)
{
  mouseEnable = enableMouseOnWidget;
  SetMouseEnableImpl(enableMouseOnWidget);
}

bool SWidget::GetMouseEnable()
{
  return mouseEnable;
}

std::string SWidget::CheckUrl(const std::string& url)
{
  std::string httpPrefix  = "http://";
  std::string httpsPrefix = "https://";
  std::string ftpPrefix   = "ftp://";
  std::string filePrefix  = "file://";

  std::string urlString = url;
  boost::to_lower(urlString);

  // Add "http://" if needed. 
  if((urlString.substr(0, httpPrefix.length()) != httpPrefix)
   &&(urlString.substr(0, httpsPrefix.length()) != httpsPrefix)
   &&(urlString.substr(0, ftpPrefix.length()) != ftpPrefix)
   &&(urlString.substr(0, filePrefix.length()) != filePrefix))
  {
    urlString = httpPrefix + url;
  }
  else
  {
    urlString = url;
  }

  return urlString;
}

void SWidget::SetIgnoreTransparentPixels(bool widgetIgnoreTransparentPixels, float tresholdColor)
{
  transparentIgnorePixels  = widgetIgnoreTransparentPixels;
  transparentTresholdColor = tresholdColor;
}

bool SWidget::GetIgnoreTransparentPixels()
{
  return transparentIgnorePixels;
}

float SWidget::GetIgnoreTransparentPixelsTreshold()
{
  return transparentTresholdColor;
}

}

---