Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

CEGUITooltip.cpp

Go to the documentation of this file.
00001 /************************************************************************
00002     filename:   CEGUITooltip.cpp
00003     created:    21/2/2005
00004     author:     Paul D Turner
00005 *************************************************************************/
00006 /*************************************************************************
00007     Crazy Eddie's GUI System (http://www.cegui.org.uk)
00008     Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
00009  
00010     This library is free software; you can redistribute it and/or
00011     modify it under the terms of the GNU Lesser General Public
00012     License as published by the Free Software Foundation; either
00013     version 2.1 of the License, or (at your option) any later version.
00014  
00015     This library is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018     Lesser General Public License for more details.
00019  
00020     You should have received a copy of the GNU Lesser General Public
00021     License along with this library; if not, write to the Free Software
00022     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00023 *************************************************************************/
00024 #include "elements/CEGUITooltip.h"
00025 #include "CEGUILogger.h"
00026 #include "CEGUIFont.h"
00027 #include "CEGUIImage.h"
00028 
00029 // Start of CEGUI namespace section
00030 namespace CEGUI
00031 {
00033     // Event name constants
00034     const String Tooltip::EventNamespace("Tooltip");
00035     const String Tooltip::EventHoverTimeChanged("HoverTimeChanged");
00036     const String Tooltip::EventDisplayTimeChanged("DisplayTimeChanged");
00037     const String Tooltip::EventFadeTimeChanged("FadeTimeChanged");
00038     const String Tooltip::EventTooltipActive("TooltipActive");
00039     const String Tooltip::EventTooltipInactive("TooltipInactive");
00040     // Property objects
00041     TooltipProperties::HoverTime    Tooltip::d_hoverTimeProperty;
00042     TooltipProperties::DisplayTime  Tooltip::d_displayTimeProperty;
00043     TooltipProperties::FadeTime     Tooltip::d_fadeTimeProperty;
00045 
00046     Tooltip::Tooltip(const String& type, const String& name) :
00047             Window(type, name)
00048     {
00049         d_hoverTime     = 0.4f;
00050         d_displayTime   = 7.5f;
00051         d_fadeTime      = 0.33f;
00052 
00053         addTooltipEvents();
00054         addTooltipProperties();
00055 
00056         setClippedByParent(false);
00057         setDestroyedByParent(false);
00058         setAlwaysOnTop(true);
00059 
00060         switchToInactiveState();
00061     }
00062 
00063     Tooltip::~Tooltip(void)
00064     {}
00065 
00066     void Tooltip::positionSelf(void)
00067     {
00068         MouseCursor& cursor = MouseCursor::getSingleton();
00069         Rect screen(System::getSingleton().getRenderer()->getRect());
00070         Rect tipRect(getUnclippedPixelRect());
00071         const Image* mouseImage = cursor.getImage();
00072 
00073         Point mousePos(cursor.getPosition());
00074         Size mouseSz(0,0);
00075 
00076         if (mouseImage)
00077         {
00078             mouseSz = mouseImage->getSize();
00079         }
00080 
00081         Point tmpPos(mousePos.d_x + mouseSz.d_width, mousePos.d_y + mouseSz.d_height);
00082         tipRect.setPosition(tmpPos);
00083 
00084         // if tooltip would be off the right of the screen,
00085         // reposition to the other side of the mouse cursor.
00086         if (screen.d_right < tipRect.d_right)
00087         {
00088             tmpPos.d_x = mousePos.d_x - tipRect.getWidth() - 5;
00089         }
00090 
00091         // if tooltip would be off the bottom of the screen,
00092         // reposition to the other side of the mouse cursor.
00093         if (screen.d_bottom < tipRect.d_bottom)
00094         {
00095             tmpPos.d_y = mousePos.d_y - tipRect.getHeight() - 5;
00096         }
00097 
00098         // set final position of tooltip window.
00099         setPosition(Absolute, tmpPos);
00100     }
00101 
00102     void Tooltip::setTargetWindow(Window* wnd)
00103     {
00104         if (wnd)
00105         {
00106             if (d_target != wnd)
00107             {
00108                 System::getSingleton().getGUISheet()->addChildWindow(this);
00109             }
00110 
00111             // set text to that of the tooltip text of the target
00112             setText(wnd->getTooltipText());
00113 
00114             // set size and potition of the tooltip window.
00115             setSize(Absolute, getTextSize());
00116             positionSelf();
00117         }
00118 
00119         resetTimer();
00120         d_target = wnd;
00121     }
00122 
00123     const Window* Tooltip::getTargetWindow()
00124     {
00125         return d_target;
00126     }
00127 
00128     Size Tooltip::getTextSize() const
00129     {
00130         const Font* fnt = getFont();
00131 
00132         if (fnt)
00133         {
00134             Rect area(System::getSingleton().getRenderer()->getRect());
00135 
00136             // get required size of the tool tip according to the text extents.
00137             // TODO: Add a proprty to allow specification of text formatting.
00138             float height = fnt->getFormattedLineCount(d_text, area, LeftAligned) * fnt->getLineSpacing();
00139             float width = fnt->getFormattedTextExtent(d_text, area, LeftAligned);
00140 
00141             return Size(width, height);
00142         }
00143         else
00144         {
00145             return Size(0,0);
00146         }
00147     }
00148 
00149     void Tooltip::resetTimer(void)
00150     {
00151         // only do the reset in active / inactive states, this is so that
00152         // the fades are not messed up by having the timer reset on them.
00153         if (d_state == Active || d_state == Inactive)
00154         {
00155             d_elapsed = 0;
00156         }
00157     }
00158 
00159     float Tooltip::getHoverTime(void) const
00160     {
00161         return d_hoverTime;
00162     }
00163 
00164     void Tooltip::setHoverTime(float seconds)
00165     {
00166         if (d_hoverTime != seconds)
00167         {
00168             d_hoverTime = seconds;
00169 
00170             WindowEventArgs args(this);
00171             onHoverTimeChanged(args);
00172         }
00173     }
00174 
00175     float Tooltip::getDisplayTime(void) const
00176     {
00177         return d_displayTime;
00178     }
00179 
00180     void Tooltip::setDisplayTime(float seconds)
00181     {
00182         if (d_displayTime != seconds)
00183         {
00184             d_displayTime = seconds;
00185 
00186             WindowEventArgs args(this);
00187             onDisplayTimeChanged(args);
00188         }
00189     }
00190 
00191     float Tooltip::getFadeTime(void) const
00192     {
00193         return d_fadeTime;
00194     }
00195 
00196     void Tooltip::setFadeTime(float seconds)
00197     {
00198         if (d_fadeTime != seconds)
00199         {
00200             d_fadeTime = seconds;
00201 
00202             WindowEventArgs args(this);
00203             onFadeTimeChanged(args);
00204         }
00205     }
00206 
00207     void Tooltip::doActiveState(float elapsed)
00208     {
00209         // if no target, switch immediately to inactive state.
00210         if (!d_target || d_target->getTooltipText().empty())
00211         {
00212             switchToInactiveState();
00213         }
00214         // else see if display timeout has been reached
00215         else if ((d_displayTime > 0) && ((d_elapsed += elapsed) >= d_displayTime))
00216         {
00217             // display time is up, switch states
00218             switchToFadeOutState();
00219         }
00220     }
00221 
00222     void Tooltip::doInactiveState(float elapsed)
00223     {
00224         if (d_target && !d_target->getTooltipText().empty() && ((d_elapsed += elapsed) >= d_hoverTime))
00225         {
00226             switchToFadeInState();
00227         }
00228     }
00229 
00230     void Tooltip::doFadeInState(float elapsed)
00231     {
00232         // if no target, switch immediately to inactive state.
00233         if (!d_target || d_target->getTooltipText().empty())
00234         {
00235             switchToInactiveState();
00236         }
00237         else
00238         {
00239             if ((d_elapsed += elapsed) >= d_fadeTime)
00240             {
00241                 setAlpha(1.0f);
00242                 switchToActiveState();
00243             }
00244             else
00245             {
00246                 setAlpha((1.0f / d_fadeTime) * d_elapsed);
00247             }
00248         }
00249     }
00250 
00251     void Tooltip::doFadeOutState(float elapsed)
00252     {
00253         // if no target, switch immediately to inactive state.
00254         if (!d_target || d_target->getTooltipText().empty())
00255         {
00256             switchToInactiveState();
00257         }
00258         else
00259         {
00260             if ((d_elapsed += elapsed) >= d_fadeTime)
00261             {
00262                 setAlpha(0.0f);
00263                 switchToInactiveState();
00264             }
00265             else
00266             {
00267                 setAlpha(1.0f - (1.0f / d_fadeTime) * d_elapsed);
00268             }
00269         }
00270     }
00271 
00272     void Tooltip::switchToInactiveState(void)
00273     {
00274         setAlpha(0.0f);
00275         d_state = Inactive;
00276         d_elapsed = 0;
00277 
00278         if (d_parent)
00279             d_parent->removeChildWindow(this);
00280 
00281         // fire event before target gets reset in case that information is required in handler.
00282         WindowEventArgs args(this);
00283         onTooltipInactive(args);
00284 
00285         d_target = 0;
00286         hide();
00287     }
00288 
00289     void Tooltip::switchToActiveState(void)
00290     {
00291         d_state = Active;
00292         d_elapsed = 0;
00293     }
00294 
00295     void Tooltip::switchToFadeInState(void)
00296     {
00297         positionSelf();
00298         d_state = FadeIn;
00299         d_elapsed = 0;
00300         show();
00301 
00302         // fire event.  Not really active at the moment, but this is the "right" time
00303         // for this event (just prior to anything getting displayed).
00304         WindowEventArgs args(this);
00305         onTooltipActive(args);
00306     }
00307 
00308     void Tooltip::switchToFadeOutState(void)
00309     {
00310         d_state = FadeOut;
00311         d_elapsed = 0;
00312     }
00313 
00314     void Tooltip::updateSelf(float elapsed)
00315     {
00316         // base class processing.
00317         Window::updateSelf(elapsed);
00318 
00319         // do something based upon current Tooltip state.
00320         switch (d_state)
00321         {
00322         case Inactive:
00323             doInactiveState(elapsed);
00324             break;
00325 
00326         case Active:
00327             doActiveState(elapsed);
00328             break;
00329 
00330         case FadeIn:
00331             doFadeInState(elapsed);
00332             break;
00333 
00334         case FadeOut:
00335             doFadeOutState(elapsed);
00336             break;
00337 
00338         default:
00339             // This should never happen.
00340             Logger::getSingleton().logEvent("Tooltip (Name: " + getName() + "of Class: " + getType() + ") is in an unknown state.  Switching to Inactive state.", Errors);
00341             switchToInactiveState();
00342         }
00343     }
00344 
00345     void Tooltip::addTooltipEvents(void)
00346     {
00347         addEvent(EventHoverTimeChanged);
00348         addEvent(EventDisplayTimeChanged);
00349         addEvent(EventFadeTimeChanged);
00350         addEvent(EventTooltipActive);
00351         addEvent(EventTooltipInactive);
00352     }
00353 
00354     void Tooltip::addTooltipProperties(void)
00355     {
00356         addProperty(&d_hoverTimeProperty);
00357         addProperty(&d_displayTimeProperty);
00358         addProperty(&d_fadeTimeProperty);
00359     }
00360 
00361     void Tooltip::onMouseEnters(MouseEventArgs& e)
00362     {
00363         positionSelf();
00364 
00365         Window::onMouseEnters(e);
00366     }
00367 
00368     void Tooltip::onTextChanged(WindowEventArgs& e)
00369     {
00370         // base class processing
00371         Window::onTextChanged(e);
00372 
00373         // set size and potition of the tooltip window to consider new text
00374         setSize(Absolute, getTextSize());
00375         positionSelf();
00376 
00377         // we do not signal we handled it, in case user wants to hear
00378         // about text changes too.
00379     }
00380 
00381     void Tooltip::onHoverTimeChanged(WindowEventArgs& e)
00382     {
00383         fireEvent(EventHoverTimeChanged, e, EventNamespace);
00384     }
00385 
00386     void Tooltip::onDisplayTimeChanged(WindowEventArgs& e)
00387     {
00388         fireEvent(EventDisplayTimeChanged, e, EventNamespace);
00389     }
00390 
00391     void Tooltip::onFadeTimeChanged(WindowEventArgs& e)
00392     {
00393         fireEvent(EventFadeTimeChanged, e, EventNamespace);
00394     }
00395 
00396     void Tooltip::onTooltipActive(WindowEventArgs& e)
00397     {
00398         fireEvent(EventTooltipActive, e, EventNamespace);
00399     }
00400 
00401     void Tooltip::onTooltipInactive(WindowEventArgs& e)
00402     {
00403         fireEvent(EventTooltipInactive, e, EventNamespace);
00404     }
00405 
00406 } // End of  CEGUI namespace section

Generated on Wed Sep 7 09:56:34 2005 for Crazy Eddies GUI System by  doxygen 1.4.3