Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/gui/gl/glgui_widget.cc @ 10258

Last change on this file since 10258 was 9869, checked in by bensch, 18 years ago

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

File size: 23.5 KB
RevLine 
[4744]1/*
[1853]2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
[1855]10
11   ### File Specific:
[5359]12   main-programmer: Benjamin Grauer
[1855]13   co-programmer: ...
[1853]14*/
15
[8989]16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_GUI
[1853]17
[5362]18#include "glgui_widget.h"
[1853]19
[7919]20#include "glgui_cursor.h"
21
[6287]22#include "material.h"
23
[5392]24#include "debug.h"
25
[8619]26#include "loading/load_param.h"
[8982]27#include "loading/resource_manager.h"
28
[7779]29namespace OrxGui
[3365]30{
[9869]31  ObjectListDefinition(GLGuiWidget);
[7779]32  /**
[8035]33   * @brief standard constructor
[7779]34  */
[8035]35  GLGuiWidget::GLGuiWidget (GLGuiWidget* parent)
[7779]36  {
37    this->init();
[8035]38
39    this->setParentWidget(parent);
[7779]40  }
[1853]41
[5359]42
[7779]43  /**
[8619]44   * @brief loads Parameters for a Style from XML
45   * @param root the XML-Element to load from.
46   */
47  void GLGuiWidget::loadParams(const TiXmlElement* root)
48  {
49
50    /// STYLE
51    LoadParam(root, "border-left", this, GLGuiWidget, setBorderLeft);
52    LoadParam(root, "border-right", this, GLGuiWidget, setBorderRight);
53    LoadParam(root, "border-top", this, GLGuiWidget, setBorderTop);
54    LoadParam(root, "border-bottom", this, GLGuiWidget, setBorderBottom);
55
56    LoadParam(root, "text-size", this, GLGuiWidget, setTextSize);
57    LoadParam(root, "background-color", this, GLGuiWidget, setBackgroundColorS);
58    LoadParam(root, "foreground-color", this, GLGuiWidget, setForegroundColorS);
59
60    //    LoadParamXML(root, "backmat", this, GLGuiWidget, loadBackgroundMaterial);
61    //    LoadParamXML(root, "frontmat", this, GLGuiWidget, loadForegroundMaterial);
62
63    LoadParam(root, "feature-position", this, GLGuiWidget, setFeaturePositionS);
64    LoadParam(root, "Font", this, GLGuiWidget, setFont);
65
66    LoadParam(root, "animated-state-changes", this, GLGuiWidget, setAnimatedStateChanges);
67  }
68
69
70  /**
[8035]71   * @brief standard deconstructor
[7779]72   */
73  GLGuiWidget::~GLGuiWidget()
74  {
[8717]75    if (this == GLGuiWidget::_mouseFocused)
76      GLGuiWidget::_mouseFocused = NULL;
77    if (this == GLGuiWidget::selected())
78      this->unselect();
[9656]79
80    if (this->_parent != NULL)
81      this->_parent->removeChildWidget(this);
[7779]82  }
[5359]83
[8035]84  GLGuiWidget* GLGuiWidget::_selected = NULL;
[8717]85  GLGuiWidget* GLGuiWidget::_mouseFocused = NULL;
[7919]86  GLGuiWidget* GLGuiWidget::_inputGrabber = NULL;
[9656]87  Font* GLGuiWidget::_defaultFont = NULL;
[5362]88
[7919]89
[7779]90  /**
91   * initializes the GUI-element
92   */
93  void GLGuiWidget::init()
94  {
[9869]95    this->registerObject(this, GLGuiWidget::_objectList);
[5392]96
[7919]97    this->_focusable = false;
98    this->_clickable = false;
[8717]99    this->_selectable = false;
[7919]100    this->_pushed = false;
[8619]101    this->_state = OrxGui::Normal;
[7919]102
[9656]103    if(GLGuiWidget::_defaultFont == NULL)
[9869]104      GLGuiWidget::_defaultFont = new Font(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + "/fonts/final_frontier.ttf", 20);
[8619]105
[9656]106    this->_font = *GLGuiWidget::_defaultFont;
[8619]107    this->resetStyle();
108
109    this->_animating = false;
110    this->_animationCycle = 0.0;
111    this->_animationDuration = 1.0;
112
113
114    this->setBackgroundColor(Color(.51, .3, .3, .5));
115    this->setBackgroundColor(Color(.3, .5, .3, 1), OrxGui::Selected);
116    this->_style[0]._background.setBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
117    this->_style[1]._background.setBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
118    this->_style[2]._background.setBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
119    this->_style[3]._background.setBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
120
[9019]121    this->setForegroundColor(Color(.8, .8, 1, 1), OrxGui::Normal);
122    this->setForegroundColor(Color(0, .4, 1.0, 1), OrxGui::Selected);
123    this->setForegroundColor(Color(0, .0, 1.0, 1), OrxGui::Focused);
[8619]124    this->setForegroundColor(Color(.1, .1, .1, 1), OrxGui::Insensitive);
125
[7779]126    this->setVisibility(GLGUI_WIDGET_DEFAULT_VISIBLE);
[5392]127
[8619]128    this->setBorderLeft(15);
129    this->setBackgroundTexture("gui_element_background.png");
[8115]130
[8619]131    this->switchState(_state);
132    this->_currentStyle = this->_style[_state];
[8035]133  }
[6287]134
[8035]135
136  void GLGuiWidget::setParentWidget(GLGuiWidget* parent)
137  {
138    this->_parent = parent;
139
140    if (parent != NULL)
141      parent->addChild2D(this);
[7779]142  }
[5392]143
[7919]144
[8717]145  void GLGuiWidget::setFrontColor(const Color& frontColor, bool instantaniously)
[7919]146  {
[8717]147    this->_currentStyle._foreground.setDiffuseColor(frontColor);
148    this->animateBack();
[7919]149  };
150
151
152  bool GLGuiWidget::focusOverWidget(const Vector2D& position) const
153  {
154    return (this->getAbsCoor2D().x < position.x && this->getAbsCoor2D().x + this->getSizeX2D() > position.x &&
[8717]155        this->getAbsCoor2D().y < position.y && this->getAbsCoor2D().y + this->getSizeY2D() > position.y);
[7779]156  }
[5391]157
[7919]158  bool GLGuiWidget::focusOverWidget(const GLGuiCursor* const cursor) const
159  {
160    return this->focusOverWidget(cursor->getAbsCoor2D());
161  }
162
[8619]163
164
[8717]165  /** @brief gives focus to this widget */
166  void GLGuiWidget::giveMouseFocus()
[8448]167  {
[8717]168    if (this->_state == OrxGui::Insensitive)
169      return ;
170
171    if (GLGuiWidget::mouseFocused() != NULL)
172      GLGuiWidget::mouseFocused()->breakMouseFocus();
173    GLGuiWidget::_mouseFocused = this;
174
175    this->switchState(OrxGui::Focused);
176
177    this->receivedFocus();
[8448]178  };
[8035]179
[8717]180  void GLGuiWidget::breakMouseFocus()
181  {
182    if (GLGuiWidget::_mouseFocused == this)
183    {
184      GLGuiWidget::_mouseFocused = NULL;
[8448]185
[8717]186      if (GLGuiWidget::_selected != this)
187        this->switchState(OrxGui::Normal);
188      else
189        this->switchState(OrxGui::Selected);
190
191      this->removedFocus();
192    }
193  };
194
195  /**
196   * @brief selects the Widget, unselecting the old one (if existing)
197   */
198  void GLGuiWidget::select()
199  {
200    if (GLGuiWidget::_selected != NULL)
201      GLGuiWidget::selected()->unselect();
202    GLGuiWidget::_selected = this;
203
204    this->switchState(OrxGui::Selected);
205  }
206
207  /**
208   * @brief unselects the current Widget.
209   *
210   * if the current Widget is not selected, nothing is done here.
211   */
212  void GLGuiWidget::unselect()
213  {
214    if (GLGuiWidget::_selected != this)
215      return;
216
217    if (GLGuiWidget::_mouseFocused == this)
218      this->switchState(OrxGui::Focused);
219    else
220      this->switchState(OrxGui::Normal);
221
222    GLGuiWidget::_selected = NULL;
223  }
224
225
[8035]226  void GLGuiWidget::resize()
227  {
228    this->backRect().setSize(this->getSize2D());
229    if (this->parent() != NULL)
230      this->parent()->resize();
231  }
232
233
234  void GLGuiWidget::click(const Vector2D& pos)
235  {
[7919]236    assert (!this->_pushed);
237    this->_pushed = true;
238
[8035]239    this->clicking(pos);
[7919]240  }
241
[8035]242  void GLGuiWidget::release(const Vector2D& pos)
[7919]243  {
244    if (this->_pushed)
245    {
[8717]246      this->releasing(pos, GLGuiWidget::_mouseFocused == this);
[7919]247      this->_pushed = false;
248    }
249  }
250
251
[8035]252  void GLGuiWidget::clicking(const Vector2D& pos)
[8717]253  {}
254
255  void GLGuiWidget::releasing(const Vector2D& pos, bool focused)
256  {}
257
258  void GLGuiWidget::receivedFocus()
[7919]259  {
260  }
261
[8717]262  void GLGuiWidget::removedFocus()
[7919]263  {
[8717]264
[7919]265  }
266
[8717]267  void GLGuiWidget::selecting()
[7919]268  {
269  }
270
[8717]271  void GLGuiWidget::unselecting()
[7919]272  {
[8717]273  }
[7919]274
[8717]275
276  void GLGuiWidget::destroying()
277  {
[7919]278  }
279
[8035]280
281  void GLGuiWidget::setWidgetSize(const Vector2D& size)
[7919]282  {
[8035]283    this->setSize2D(size);
284    this->resize();
[7919]285
[8035]286  }
[7919]287
288
[8035]289  void GLGuiWidget::setWidgetSize(float x, float y)
[7779]290  {
[8035]291    this->setWidgetSize(Vector2D(x, y));
292  }
[5391]293
[7779]294  void GLGuiWidget::show()
295  {
296    this->setVisibility(true);
[8115]297    this->showing();
[7779]298  }
[6287]299
[8035]300
[8312]301
[7779]302  void GLGuiWidget::hide()
303  {
304    this->setVisibility(false);
[8115]305    this->hiding();
[7779]306  }
[6287]307
[8619]308
309  /**
310   * @brief resets the Style to the default Settings.
311   */
312  void GLGuiWidget::resetStyle()
313  {
314    this->setBorderLeft(1.0);
315    this->setBorderRight(1.0);
316    this->setBorderTop(1.0);
317    this->setBorderBottom(1.0);
318
319    this->setTextSize(20.0);
320    this->setBackgroundColor(1.0);
321    this->setForegroundColor(1.0);
322
323    this->setFeaturePosition(FeatureLeft);
324
325    this->setAnimatedStateChanges(true);
326  }
327
328
329  /**
330   * @brief sets the Width of the left border for all States
331   * @param value the borderWidth
332   */
333  void GLGuiWidget::setBorderLeft(float value)
334  {
335    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
336      setBorderLeft(value, (OrxGui::State)i);
337  }
338
339  /**
340   * @brief sets the Width of the left border.
341   * @param value the borderWidth
342   * @param state the State to set the borderwidth to
343   */
344  void GLGuiWidget::setBorderLeft(float value, OrxGui::State state)
345  {
346    _style[state]._borderLeft = value;
347    if (state == _state)
348      _currentStyle._borderLeft = value;
349  }
350
351  /**
352   * @brief sets the Width of the left border.
353   * @param value the borderWidth
354   * @param stateName the State to set the borderwidth to
355   */
356  void GLGuiWidget::setBorderLeftS(float value, const std::string& stateName)
357  {
358    OrxGui::State state;
359    if (getState(stateName, &state))
360      this->setBorderLeft(value, state);
361    else
362      this->setBorderLeft(value);
363  }
364
365  /**
366   * @brief sets the Width of the right border for all states.
367   * @param value the borderWidth
368   */
369  void GLGuiWidget::setBorderRight(float value)
370  {
371    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
372      setBorderRight(value, (OrxGui::State)i);
373  }
374
375  /**
376   * @brief sets the Width of the right border.
377   * @param value the borderWidth
378   * @param state the State to setup.
379   */
380  void GLGuiWidget::setBorderRight(float value, OrxGui::State state)
381  {
382    _style[state]._borderRight = value;
383    if (state == _state)
384      _currentStyle._borderRight = value;
385  }
386
387  /**
388   * @brief sets the Width of the right border.
389   * @param value the borderWidth
390   * @param stateName the State to setup.
391   */
392  void GLGuiWidget::setBorderRightS(float value, const std::string& stateName)
393  {
394    OrxGui::State state;
395    if (getState(stateName, &state))
396      this->setBorderRight(value, state);
397    else
398      this->setBorderRight(value);
399  }
400
401
402  /**
403   * @brief sets the Width of the top border for all states.
404   * @param value the borderWidth
405   */
406  void GLGuiWidget::setBorderTop(float value)
407  {
408    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
409      setBorderTop(value, (OrxGui::State)i);
410  }
411
412  /**
413   * @brief sets the Width of the top border.
414   * @param value the borderWidth
415   * @param state the State to setup.
416   */
417  void GLGuiWidget::setBorderTop(float value, OrxGui::State state)
418  {
419    _style[state]._borderTop = value;
420    if (state == _state)
421      _currentStyle._borderTop = value;
422  }
423
424  /**
425   * @brief sets the Width of the top border.
426   * @param value the borderWidth
427   * @param stateName the State to setup.
428   */
429  void GLGuiWidget::setBorderTopS(float value, const std::string& stateName)
430  {
431    OrxGui::State state;
432    if (getState(stateName, &state))
433      this->setBorderTop(value, state);
434    else
435      this->setBorderTop(value);
436  }
437
438
439  /**
440   * @brief sets the Width of the bottom border for all states.
441   * @param value the borderWidth
442   */
443  void GLGuiWidget::setBorderBottom(float value)
444  {
445    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
446      setBorderBottom(value, (OrxGui::State)i);
447  }
448
449  /**
450   * @brief sets the Width of the bottom border.
451   * @param value the borderWidth
452   * @param state the State to setup.
453   */
454  void GLGuiWidget::setBorderBottom(float value, OrxGui::State state)
455  {
456    _style[state]._borderBottom = value;
457    if (state == _state)
458      _currentStyle._borderBottom = value;
459
460  }
461
462  /**
463   * @brief sets the Width of the bottom border for all states.
464   * @param value the borderWidth
465   * @param stateName the State to setup.
466   */
467  void GLGuiWidget::setBorderBottomS(float value, const std::string& stateName)
468  {
469    OrxGui::State state;
470    if (getState(stateName, &state))
471      this->setBorderBottom(value, state);
472    else
473      this->setBorderBottom(value);
474  }
475
476
477  /**
478   * @brief sets the TextSize for all states.
479   * @param value the TextSize
480   */
481  void GLGuiWidget::setTextSize(float value)
482  {
483    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
484      setTextSize(value, (OrxGui::State)i);
485  }
486
487  /**
488   * @brief sets the TextSize.
489   * @param value the TextSize.
490   * @param state: the State to setup
491   */
492  void GLGuiWidget::setTextSize(float value, OrxGui::State state)
493  {
494    _style[state]._textSize = value;
495    if (state == _state)
496      _currentStyle._textSize = value;
497  }
498
499  /**
500   * @brief sets the TextSize.
501   * @param value the TextSize.
502   * @param stateName: the State to setup
503   */
504  void GLGuiWidget::setTextSizeS(float value, const std::string& stateName)
505  {
506    OrxGui::State state;
507    if (getState(stateName, &state))
508      this->setTextSize(value, state);
509    else
510      this->setTextSize(value);
511  }
512
513
514  /**
515   * @brief sets the Background Color for all States.
516   * @param color the Color.
517   */
518  void GLGuiWidget::setBackgroundColor(const Color& color)
519  {
520    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
521      setBackgroundColor(color, (OrxGui::State)i);
522  }
523
524  /**
525   * @brief sets the Background Color.
526   * @param color the Color.
527   * @param state: the State to setup
528   */
529  void GLGuiWidget::setBackgroundColor(const Color& color, OrxGui::State state)
530  {
531    _style[state]._background.setDiffuseColor(color);
532    if (state == _state)
533      _currentStyle._background.setDiffuseColor(color);
534
535  }
536
537  /**
538   * @brief sets the Background Color.
539   * @param r the Color's red part.
540   * @param g the Color's green part.
541   * @param b the Color's blue part.
542   * @param a the Color's alpha part.
543   * @param stateName: the State to setup
544   */
545  void GLGuiWidget::setBackgroundColorS(float r, float g, float b, float a, const std::string& stateName)
546  {
547    OrxGui::State state;
548    if (getState(stateName, &state))
549      this->setBackgroundColor(Color(r,g,b,a), state);
550    else
551      this->setBackgroundColor(Color(r,g,b,a));
552  }
553
554
555  /**
556   * @brief sets the Background Texture for all States.
557   * @param texture the Texture.
558   */
559  void GLGuiWidget::setBackgroundTexture(const Texture& texture)
560  {
561    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
562      setBackgroundTexture(texture, (OrxGui::State)i);
563  }
564
565  /**
566  * @brief sets the Background Texture to all States.
567  * @param textureName the Texture's fileName.
568   */
569  void GLGuiWidget::setBackgroundTexture(const std::string& textureName)
570  {
571    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
572      _style[i]._background.setDiffuseMap(textureName);
573    this->_currentStyle._background.setDiffuseMap(textureName);
574  }
575
576  /**
577   * @brief sets the Background Texture.
578   * @param texture the Texture.
579   * @param state the State to setup.
580   */
581  void GLGuiWidget::setBackgroundTexture(const Texture& texture, OrxGui::State state)
582  {
583    _style[state]._background.setDiffuseMap(texture);
584    if (state == _state)
585      _currentStyle._background.setDiffuseMap(texture);
586  }
587
588
589
590  /**
591   * @brief sets the Background Texture.
592   * @param texture the Texture.
593   * @param stateName the State to setup.
594   */
595  void GLGuiWidget::setBackgroundTexture(const std::string& textureName, const std::string& stateName)
596  {
597    OrxGui::State state;
598    if (getState(stateName, &state))
599      ; /// FIXME this->setBackgroundTexture(textureName, state);
600    else
601      ; ///    this->setBackgroundTexture(textureName);
602  }
603
604
605  /**
606   * @brief sets the Foreground Color for all States.
607   * @param color the Color.
608   */
609  void GLGuiWidget::setForegroundColor(const Color& color)
610  {
611    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
612      setForegroundColor(color, (OrxGui::State)i);
613  }
614
615  /**
616   * @brief sets the Foreground Color.
617   * @param color the Color.
618   * @param state the State to setup
619   */
620  void GLGuiWidget::setForegroundColor(const Color& color, OrxGui::State state)
621  {
622    _style[state]._foreground.setDiffuseColor(color);
623    if (state == _state)
624      _currentStyle._foreground.setDiffuseColor(color);
625
626  }
627
628  /**
629   * @brief sets the Foreground Color.
630   * @param r the Color's red part.
631   * @param g the Color's green part.
632   * @param b the Color's blue part.
633   * @param a the Color's alpha part.
634   * @param stateName: the State to setup
635   */
636  void GLGuiWidget::setForegroundColorS(float r, float g, float b, float a, const std::string& stateName)
637  {
638    OrxGui::State state;
639    if (getState(stateName, &state))
640      this->setForegroundColor(Color(r,g,b,a), state);
641    else
642      this->setForegroundColor(Color(r,g,b,a));
643  }
644
645
[8990]646    /**
647   * @brief sets the Foreground Texture for all States.
648   * @param texture the Texture.
649     */
650  void GLGuiWidget::setForegroundTexture(const Texture& texture)
651  {
652    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
653      setForegroundTexture(texture, (OrxGui::State)i);
654  }
655
656  /**
657   * @brief sets the Foreground Texture to all States.
658   * @param textureName the Texture's fileName.
659   */
660  void GLGuiWidget::setForegroundTexture(const std::string& textureName)
661  {
662    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
663      _style[i]._foreground.setDiffuseMap(textureName);
664    this->_currentStyle._foreground.setDiffuseMap(textureName);
665  }
666
667  /**
668   * @brief sets the Foreground Texture.
669   * @param texture the Texture.
670   * @param state the State to setup.
671   */
672  void GLGuiWidget::setForegroundTexture(const Texture& texture, OrxGui::State state)
673  {
674    _style[state]._background.setDiffuseMap(texture);
675    if (state == _state)
676      _currentStyle._background.setDiffuseMap(texture);
677  }
678
679
680
681  /**
682   * @brief sets the Foreground Texture.
683   * @param texture the Texture.
684   * @param stateName the State to setup.
685   */
686  void GLGuiWidget::setForegroundTexture(const std::string& textureName, const std::string& stateName)
687  {
688    OrxGui::State state;
689    if (getState(stateName, &state))
690      ; /// FIXME this->setForegroundTexture(textureName, state);
691    else
692      ; ///    this->setForegroundTexture(textureName);
693  }
694
695
[8619]696  void GLGuiWidget::loadBackgroundMaterial(const Material& material)
697  {
698    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
699      this->loadForegroundMaterial(material, (OrxGui::State)i);
700  }
701
702  void GLGuiWidget::loadBackgroundMaterial(const Material& material, OrxGui::State state)
703  {
704    this->_style[state]._background = material;
705    if (state == _state)
706      _currentStyle._background = material;
707
708  }
709
710  void GLGuiWidget::loadBackgroundMaterial(const TiXmlElement* element)
711  {
712    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
713      this->loadBackgroundMaterial(element, (OrxGui::State)i);
714  }
715
716  void GLGuiWidget::loadBackgroundMaterial(const TiXmlElement* element, OrxGui::State state)
717  {
718    this->_style[state]._background.loadParams(element);
719    if (state == _state)
720      this->_currentStyle._background = _style[state]._background;
721  }
722
723  void GLGuiWidget::loadBackgroundMaterialS(const TiXmlElement* element, const std::string& stateName)
724  {
725    OrxGui::State state;
726    if (getState(stateName, &state))
727      this->loadBackgroundMaterial(element, state);
728    else
729      this->loadBackgroundMaterial(element);
730  }
731
732  void GLGuiWidget::loadForegroundMaterial(const Material& material)
733{}
734  void GLGuiWidget::loadForegroundMaterial(const Material& material, OrxGui::State state)
735  {}
736  void GLGuiWidget::loadForegroundMaterial(const TiXmlElement* element, OrxGui::State state)
737  {}
738  void GLGuiWidget::loadForegroundMaterialS(const TiXmlElement* element, const std::string& stateName)
739  {}
740
741
742  /**
743   * @brief sets the Feature-Position.
744   * @param featurePosition the Feature-Position.
745   */
746  void GLGuiWidget::setFeaturePosition(FeaturePosition featurePosition)
747  {
748    this->_featurePosition = featurePosition;
749  }
750
751  /**
752   * @brief sets the Feature-Position by converting from a String.
753   * @param featurePosition the Feature-Position.
754   */
755  void GLGuiWidget::setFeaturePositionS(const std::string& featurePosition)
756  {
757    for (unsigned int i = 0; i < 4; ++i)
758    {
759      if (featurePosition == FeaturePositionString[i])
760      {
761        this->setFeaturePosition((FeaturePosition)i);
762      }
763    }
764  }
765
766  /**
767   * @brief sets the Font.
768   * @param font the Font.
769   */
[8769]770  void GLGuiWidget::setFont(const Font& font)
[8619]771  {
772    this->_font = font;
773  }
774
775  /**
776   * @brief sets the font from a Font-Name.
777   * @param fontName the FileName of the Font.
778   */
[8769]779  void GLGuiWidget::setFont(const std::string& fontName, unsigned int renderSize)
[8619]780  {
[9656]781    this->setFont(Font(fontName, renderSize));
[8619]782  }
783
784  /**
785   * @brief sets the AnimatedState.
786   * @param animated: it states-changes should animate true, otherwise false.
787   */
788  void GLGuiWidget::setAnimatedStateChanges(bool animated)
789  {
790    this->_animatedStateChanges = animated;
791  }
792
793
794  void GLGuiWidget::switchState(OrxGui::State state)
795  {
796    //this->_currentStyle = this->_style[state];
797    this->_state = state;
[9406]798    PRINTF(4)("%s::%s Switches to state %s\n", this->getClassCName(), this->getCName(), OrxGui::StateString[state].c_str());
[8619]799
800    this->animateBack();
801  }
802
803
804  void GLGuiWidget::animateBack()
805  {
806    this->_animating = true;
807    this->_animationCycle = 0.0f;
808  }
809
810
[8448]811  void GLGuiWidget::tick(float dt)
812  {
[8619]813    if (this->_animating)
[8448]814    {
[8619]815      this->foregroundColor();
816
817      _animationCycle += dt / _animationDuration;
818      if (_animationCycle >= 1.0)
[8448]819      {
[8619]820        _currentStyle._foreground.diffuseColor() = this->foregroundColor(_state);
821        _currentStyle._background.diffuseColor() = this->backgroundColor(_state);
822        _animating = false;
[8448]823      }
[8619]824      else
825      {
826        _currentStyle._foreground.diffuseColor().slerp(this->foregroundColor(_state), _animationCycle);
827        _currentStyle._background.diffuseColor().slerp(this->backgroundColor(_state), _animationCycle);
828      }
829      this->updateFrontColor();
[8448]830    }
831  }
[6431]832
[8448]833
[8035]834  /**
835   * USE THIS FUNCTION ONLY FROM DERIVED CLASS
836   */
[7779]837  void GLGuiWidget::draw() const
838  {
[8619]839    this->background().select();
[8035]840    this->drawRect(this->backRect());
[8619]841    this->background().unselect();
[7779]842  }
843
[8619]844
845  /**
846   * @param stateName the Name of a State.
847   * @param state the found State is returned here if found.
848   * @returns true if String is found, false otherwise.
849   */
850  bool GLGuiWidget::getState(const std::string& stateName, OrxGui::State* state)
851  {
852    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
853      if (stateName == OrxGui::StateString[i])
[8717]854      {
855        *state = (OrxGui::State)i;
856        return true;
857      }
[8619]858    return false;
859  }
860
861  /**
862   * @brief print out some nice debug output about the Widget.
863   */
[8717]864  void GLGuiWidget::debug(unsigned int level) const
[8619]865  {
[9406]866    PRINT(0)("Debug of %s::%s - WidgetPart ", this->getClassCName(), this->getCName());
[8619]867    if (_parent != NULL)
[9406]868      PRINT(0)("- Parent %s::%s ", _parent->getClassCName(), _parent->getCName());
[8619]869    PRINT(0)("- State: %s", StateString[_state].c_str());
870
871    if (_focusable)
872      PRINT(0)("- focusable ");
873    if (_clickable)
874      PRINT(0)("- Clickable ");
875    if (_pushed)
876      PRINT(0)("- Pushed ");
877    PRINT(0)("\n");
878
879
880    PRINT(0)("Minimum Size %0.2f %0.2f ", _minSize.x, _minSize.y);
881    PRINT(0)("Back Rect: ");
882    _backRect.debug();
883    PRINT(0)("Style:\n");
884
885    for (unsigned int i = 0; i < GLGUI_STATE_COUNT; ++i)
886    {
887      PRINT(0)("In State %s: \n", StateString[i].c_str());
888
889      PRINT(0)("  Borders: Left: %0.2f, Right: %0.2f, Top: %0.2f, Bottom %0.2f\n",
890               _style[i]._borderLeft, _style[i]._borderRight, _style[i]._borderTop, _style[i]._borderBottom);
891      PRINT(0)("  TextSize %0.2f\n", _style[i]._textSize);
892      PRINT(0)("  BackgroundColor: "); _style[i]._background.diffuseColor().debug();
893      PRINT(0)("  ForegroundColor: "); _style[i]._foreground.diffuseColor().debug();
894      PRINT(0)("\n");
895    }
896
897
898    PRINT(0)(" Feature at %s ", FeaturePositionString[_featurePosition].c_str());
899    /// TODO    PRINT(0)("");    Font*               _font;                 //!< The Font used in the current Widget.
900
901    if (_animatedStateChanges)
902      PRINT(0)("- AnimatedStateChanges");
903    PRINT(0)("\n");
904
905    /*
906    if (_animating)
907      PRINT(0)("- Animated ");
908
909    //
910    float               _animationCycle;
911    float               _animationDuration;
912    StatedStyle         _currentStyle;
913    OrxGui::State       _currentState;
914    */
915  }
916
917
[6287]918}
Note: See TracBrowser for help on using the repository browser.