ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
VP1MaterialButton::Imp Class Reference
Collaboration diagram for VP1MaterialButton::Imp:

Public Member Functions

void initEditWindow ()
 
void applyValuesToMaterial (SoMaterial *, bool preview=false)
 
QColor guiAmbientColour () const
 
QColor guiDiffuseColour () const
 
QColor guiSpecularColour () const
 
QColor guiEmissiveColour () const
 
int guiTransparency () const
 
int guiShininess () const
 
QString printFloat (const double &d)
 
QString toSbColTxt (const QColor &c)
 
void setLastAppliedFromCurrent ()
 
bool previewEqualToLastApplied () const
 
void updateApplyResetButtons ()
 
void adaptGuiForMode ()
 
void switchModeBasedOnLastApplied ()
 
void adaptGuiAndMaterialsToLastApplied ()
 
QColor emissiveColourFromSimpleParameters (const QColor &simpleColour, const double &brightness) const
 
double brightnessEstimateFromDetailedParameters (const QColor &diffuseColour, const QColor &emissiveColour) const
 
void blockGuiSignals (bool)
 

Static Public Member Functions

static SbColor qcol2sbcol (const QColor &)
 
static QColor sbcol2qcol (const SbColor &)
 
static double distSq (const QColor &a, const QColor &b)
 
static bool equal (const QColor &a, const QColor &b, const double &tol=1.0e-6)
 
static QColor simpleAmbient ()
 
static QColor simpleSpecular ()
 
static int simpleShininess ()
 

Public Attributes

VP1MaterialButton * theclass
 
QPoint dragStartPosition
 
bool simplemode
 
int dim
 
QString materialtext
 
QWidget * editwindow
 
SoMaterial * preview_material
 
Ui::VP1MaterialButtonForm editwindow_ui
 
SoQtRenderArea * renderarea
 
SoSwitch * previewswitch
 
QList< SoMaterial * > handledmaterials
 
QColor lastapplied_ambient
 
QColor lastapplied_diffuse
 
QColor lastapplied_specular
 
QColor lastapplied_emissive
 
int lastapplied_shininess
 
int lastapplied_transparency
 
int lastapplied_brightness
 
int blockcount
 

Detailed Description

Definition at line 48 of file VP1MaterialButton.cxx.

Member Function Documentation

◆ adaptGuiAndMaterialsToLastApplied()

void VP1MaterialButton::Imp::adaptGuiAndMaterialsToLastApplied ( )

Definition at line 200 of file VP1MaterialButton.cxx.

201 {
202  switchModeBasedOnLastApplied();
203 
204  if (VP1Msg::verbose()) {
205  theclass->messageVerbose("Copied values from material: "
206  "diffuse="+str(lastapplied_diffuse)
207  +", ambient="+str(lastapplied_ambient)
208  +", specular="+str(lastapplied_specular)
209  +", emissive="+str(lastapplied_emissive)
210  +", shininess="+str(lastapplied_shininess)
211  +", transparency="+str(lastapplied_transparency)
212  );
213  }
214 
215  if (editwindow) {
216  if (VP1Msg::verbose()){
217  theclass->messageVerbose(" => and updating preview.");
218  }
219  blockGuiSignals(true);
220  editwindow_ui.colbutton_ambient->setColor(lastapplied_ambient);
221  editwindow_ui.colbutton_diffuse->setColor(lastapplied_diffuse);
222  editwindow_ui.colbutton_specular->setColor(lastapplied_specular);
223  editwindow_ui.colbutton_emissive->setColor(lastapplied_emissive);
224  editwindow_ui.slider_shininess->setValue(lastapplied_shininess);
225  editwindow_ui.label_num_shininess->setNum(lastapplied_shininess);
226  editwindow_ui.colbutton_simple_colour->setColor(lastapplied_diffuse);
227  editwindow_ui.slider_simple_transparency->setValue(lastapplied_transparency);
228  if (lastapplied_brightness!=-1) {
229  editwindow_ui.slider_simple_brightness->setValue(lastapplied_brightness);
230  editwindow_ui.label_num_simple_brightness->setNum(lastapplied_brightness);
231  }
232  editwindow_ui.slider_transparency->setValue(lastapplied_transparency);
233  editwindow_ui.label_num_transparency->setNum(lastapplied_transparency);
234  editwindow_ui.label_num_simple_transparency->setNum(lastapplied_transparency);
235  blockGuiSignals(false);
236  theclass->updatePreview();
237  }
238  theclass->apply();
239  updateApplyResetButtons();
240 }

◆ adaptGuiForMode()

void VP1MaterialButton::Imp::adaptGuiForMode ( )

Definition at line 703 of file VP1MaterialButton.cxx.

704 {
705  if (!editwindow)
706  return;
707  editwindow_ui.stackedWidget->setCurrentWidget(simplemode?editwindow_ui.page_simple:editwindow_ui.page_detailed);
708  editwindow_ui.pushButton_switch_mode->setText("&Switch to "+QString(simplemode?"detailed":"simple")+" mode");
709  if (simplemode)
710  editwindow_ui.pushButton_switch_mode->setToolTip("Switch to detailed material editing for more options.");
711  else
712  editwindow_ui.pushButton_switch_mode->setToolTip("Switch to a simpler material editing. This might discard some information.");
713 }

◆ applyValuesToMaterial()

void VP1MaterialButton::Imp::applyValuesToMaterial ( SoMaterial *  m,
bool  preview = false 
)

Definition at line 405 of file VP1MaterialButton.cxx.

406 {
407  if (!m)
408  return;
409  bool save = m->enableNotify(false);
410  if (preview) {
411  //Take value directly from gui:
412  if (!editwindow)
413  initEditWindow();
414  m->ambientColor.setValue(qcol2sbcol(guiAmbientColour()));
415  m->diffuseColor.setValue(qcol2sbcol(guiDiffuseColour()));
416  m->specularColor.setValue(qcol2sbcol(guiSpecularColour()));
417  m->emissiveColor.setValue(qcol2sbcol(guiEmissiveColour()));
418  m->shininess.setValue(std::max(0.0f,std::min(1.0f,guiShininess()/100.0f)));
419  m->transparency.setValue(std::max(0.0f,std::min(1.0f,guiTransparency()/100.0f)));
420  } else {
421  //Take values from stored "last" settings:
422  m->ambientColor.setValue(qcol2sbcol(lastapplied_ambient));
423  m->diffuseColor.setValue(qcol2sbcol(lastapplied_diffuse));
424  m->specularColor.setValue(qcol2sbcol(lastapplied_specular));
425  m->emissiveColor.setValue(qcol2sbcol(lastapplied_emissive));
426  m->shininess.setValue(std::max(0.0f,std::min(1.0f,lastapplied_shininess/100.0f)));
427  m->transparency.setValue(std::max(0.0f,std::min(1.0f,lastapplied_transparency/100.0f)));
428  }
429  if (save) {
430  m->enableNotify(true);
431  m->touch();
432  }
433 }

◆ blockGuiSignals()

void VP1MaterialButton::Imp::blockGuiSignals ( bool  b)

Definition at line 280 of file VP1MaterialButton.cxx.

281 {
282  if (b)
283  ++blockcount;
284  else
285  --blockcount;
286  if ( (b&&blockcount==1) || (!b&&blockcount==0) ) {
287  editwindow_ui.colbutton_ambient->blockSignals(b);
288  editwindow_ui.colbutton_diffuse->blockSignals(b);
289  editwindow_ui.colbutton_specular->blockSignals(b);
290  editwindow_ui.colbutton_emissive->blockSignals(b);
291  editwindow_ui.slider_shininess->blockSignals(b);
292  editwindow_ui.colbutton_simple_colour->blockSignals(b);
293  editwindow_ui.slider_simple_brightness->blockSignals(b);
294  editwindow_ui.slider_simple_transparency->blockSignals(b);
295  editwindow_ui.slider_transparency->blockSignals(b);
296  editwindow_ui.radioButton_cone->blockSignals(b);
297  editwindow_ui.radioButton_lines->blockSignals(b);
298  editwindow_ui.radioButton_box->blockSignals(b);
299  editwindow_ui.pushButton_apply->blockSignals(b);
300  editwindow_ui.pushButton_reset->blockSignals(b);
301  editwindow_ui.pushButton_switch_mode->blockSignals(b);
302  }
303 }

◆ brightnessEstimateFromDetailedParameters()

double VP1MaterialButton::Imp::brightnessEstimateFromDetailedParameters ( const QColor &  diffuseColour,
const QColor &  emissiveColour 
) const

Definition at line 536 of file VP1MaterialButton.cxx.

537 {
538  double df_r(diffuseColour.redF()),df_g(diffuseColour.greenF()),df_b(diffuseColour.blueF());
539  double em_r(emissiveColour.redF()),em_g(emissiveColour.greenF()),em_b(emissiveColour.blueF());
540  const double dotp = em_r*df_r + em_g*df_g + em_b*df_b;
541  const double df_mag2 = df_r*df_r + df_g*df_g + df_b*df_b;
542  return std::max<double>(0.0,std::min<double>(100.0,dotp/df_mag2));
543 }

◆ distSq()

double VP1MaterialButton::Imp::distSq ( const QColor &  a,
const QColor &  b 
)
static

Definition at line 513 of file VP1MaterialButton.cxx.

514 {
515  const double dRed(a.redF()-b.redF());
516  const double dGreen(a.greenF()-b.greenF());
517  const double dBlue(a.blueF()-b.blueF());
518  return dRed*dRed+dGreen*dGreen+dBlue*dBlue;
519 }

◆ emissiveColourFromSimpleParameters()

QColor VP1MaterialButton::Imp::emissiveColourFromSimpleParameters ( const QColor &  simpleColour,
const double &  brightness 
) const

Definition at line 528 of file VP1MaterialButton.cxx.

529 {
530  return QColor::fromRgbF(std::min(1.0,std::max(0.0,brightness*simpleColour.redF())),
531  std::min(1.0,std::max(0.0,brightness*simpleColour.greenF())),
532  std::min(1.0,std::max(0.0,brightness*simpleColour.blueF())));
533 }

◆ equal()

bool VP1MaterialButton::Imp::equal ( const QColor &  a,
const QColor &  b,
const double &  tol = 1.0e-6 
)
static

Definition at line 522 of file VP1MaterialButton.cxx.

523 {
524  return a == b || distSq(a,b) < tol;
525 }

◆ guiAmbientColour()

QColor VP1MaterialButton::Imp::guiAmbientColour ( ) const

Definition at line 546 of file VP1MaterialButton.cxx.

547 {
548  return simplemode ? simpleAmbient() : editwindow_ui.colbutton_ambient->color();
549 }

◆ guiDiffuseColour()

QColor VP1MaterialButton::Imp::guiDiffuseColour ( ) const

Definition at line 552 of file VP1MaterialButton.cxx.

553 {
554  return simplemode ? editwindow_ui.colbutton_simple_colour->color() : editwindow_ui.colbutton_diffuse->color();
555 }

◆ guiEmissiveColour()

QColor VP1MaterialButton::Imp::guiEmissiveColour ( ) const

Definition at line 564 of file VP1MaterialButton.cxx.

565 {
566  if (simplemode)
567  return emissiveColourFromSimpleParameters(editwindow_ui.colbutton_simple_colour->color(),editwindow_ui.slider_simple_brightness->value()/100.0);
568  else
569  return editwindow_ui.colbutton_emissive->color();
570 }

◆ guiShininess()

int VP1MaterialButton::Imp::guiShininess ( ) const

Definition at line 580 of file VP1MaterialButton.cxx.

581 {
582  return simplemode ? simpleShininess() : editwindow_ui.slider_shininess->value();
583 }

◆ guiSpecularColour()

QColor VP1MaterialButton::Imp::guiSpecularColour ( ) const

Definition at line 558 of file VP1MaterialButton.cxx.

559 {
560  return simplemode ? simpleSpecular() : editwindow_ui.colbutton_specular->color();
561 }

◆ guiTransparency()

int VP1MaterialButton::Imp::guiTransparency ( ) const

Definition at line 573 of file VP1MaterialButton.cxx.

574 {
575  return simplemode ? editwindow_ui.slider_transparency->value() : editwindow_ui.slider_simple_transparency->value();
576 }

◆ initEditWindow()

void VP1MaterialButton::Imp::initEditWindow ( )

Definition at line 307 of file VP1MaterialButton.cxx.

308 {
309  if (editwindow)
310  return;
311  if(VP1Msg::verbose()){
312  theclass->messageVerbose("Initialising material editor dialog");
313  }
314  editwindow = new QWidget(0,Qt::WindowStaysOnTopHint);
315  editwindow_ui.setupUi(editwindow);
316  editwindow_ui.colbutton_ambient->setColor(lastapplied_ambient);
317  editwindow_ui.colbutton_diffuse->setColor(lastapplied_diffuse);
318  editwindow_ui.colbutton_specular->setColor(lastapplied_specular);
319  editwindow_ui.colbutton_emissive->setColor(lastapplied_emissive);
320  editwindow_ui.slider_shininess->setValue(lastapplied_shininess);
321  editwindow_ui.label_num_shininess->setNum(lastapplied_shininess);
322  editwindow_ui.slider_transparency->setValue(lastapplied_transparency);
323  editwindow_ui.slider_simple_transparency->setValue(lastapplied_transparency);
324  editwindow_ui.label_num_transparency->setNum(lastapplied_transparency);
325  editwindow_ui.label_num_simple_transparency->setNum(lastapplied_transparency);
326  editwindow_ui.slider_simple_brightness->setValue(lastapplied_brightness);
327  editwindow_ui.label_num_simple_brightness->setNum(lastapplied_brightness);
328  editwindow_ui.colbutton_simple_colour->setColor(lastapplied_diffuse);
329 
330  #if defined BUILDVP1LIGHT
331  bool checkDisallowMultipleChannels = VP1QtUtils::expertSettingIsOn("general","ExpertSettings/VP1_DISALLOW_MULTIPLE_CHANNELS");
332  #else
333  bool checkDisallowMultipleChannels = VP1QtUtils::environmentVariableIsOn("VP1_DISALLOW_MULTIPLE_CHANNELS");
334  #endif
335 
336  if (!checkDisallowMultipleChannels) {
337  SoSeparator * userroot = new SoSeparator;
338  SoComplexity * complexity = new SoComplexity;
339  complexity->value = 1.0;
340  userroot->addChild(complexity);
341  preview_material = new SoMaterial;
342  userroot->addChild(preview_material);
343  previewswitch = new SoSwitch;
344  previewswitch->addChild(new SoCube);
345  previewswitch->addChild(new SoCone);
346  SoSeparator * linesep = new SoSeparator;
347  SoDrawStyle * linedrawstyle = new SoDrawStyle;
348  linedrawstyle->style = SoDrawStyleElement::LINES;
349  linedrawstyle->lineWidth = 2;
350  linesep->addChild(linedrawstyle);
351  linesep->addChild(new SoCube);
352  previewswitch->addChild(linesep);
353  previewswitch->whichChild = 0;
354  userroot->addChild(previewswitch);
355  VP1ExaminerViewer * viewer = new VP1ExaminerViewer(editwindow_ui.widget_3dpreview,false);
356  viewer->setDecoration(false);
357  viewer->removeDecorationMenuOption();
358  viewer->setTransparencyType( SoGLRenderAction::DELAYED_BLEND );
359  viewer->viewAll();
360  renderarea=viewer;
361  renderarea->setAntialiasing(true,4);
362  renderarea->setSceneGraph(userroot);
363  renderarea->setBackgroundColor(SbColor(0.0f, 0.0f, 0.0f));
364  } else {
365  //Put some sort of warning in that 'preview disabled by VP1_DISALLOW_MULTIPLE_CHANNELS env. var.'
366  //int editwindow_ui.widget_3dpreview. Fixme.
367  }
368 
369  connect(editwindow_ui.colbutton_ambient,SIGNAL(colorChanged(const QColor&)),theclass,SLOT(updatePreview()));
370  connect(editwindow_ui.colbutton_diffuse,SIGNAL(colorChanged(const QColor&)),theclass,SLOT(updatePreview()));
371  connect(editwindow_ui.colbutton_specular,SIGNAL(colorChanged(const QColor&)),theclass,SLOT(updatePreview()));
372  connect(editwindow_ui.colbutton_emissive,SIGNAL(colorChanged(const QColor&)),theclass,SLOT(updatePreview()));
373  connect(editwindow_ui.slider_shininess,SIGNAL(valueChanged(int)),theclass,SLOT(updatePreview()));
374  connect(editwindow_ui.colbutton_simple_colour,SIGNAL(colorChanged(const QColor&)),theclass,SLOT(updatePreview()));
375  connect(editwindow_ui.slider_simple_brightness,SIGNAL(valueChanged(int)),theclass,SLOT(updatePreview()));
376  //Transparency sliders needs to be coordinated:
377  connect(editwindow_ui.slider_simple_transparency,SIGNAL(valueChanged(int)),theclass,SLOT(transparencyChanged()));
378  connect(editwindow_ui.slider_transparency,SIGNAL(valueChanged(int)),theclass,SLOT(transparencyChanged()));
379 
380  editwindow_ui.radioButton_cone->setChecked(true);
381 
382  switchModeBasedOnLastApplied();
383 
384  theclass->updatePreviewSceneAndBgd();
385 
386  connect(editwindow_ui.radioButton_cone,SIGNAL(toggled(bool)),theclass,SLOT(updatePreviewSceneAndBgd()));
387  connect(editwindow_ui.radioButton_box,SIGNAL(toggled(bool)),theclass,SLOT(updatePreviewSceneAndBgd()));
388 
389  theclass->updatePreview();
390  setLastAppliedFromCurrent();
391 
392  connect(editwindow_ui.pushButton_apply,SIGNAL(clicked()),theclass,SLOT(apply()));
393  connect(editwindow_ui.pushButton_reset,SIGNAL(clicked()),theclass,SLOT(reset()));
394  connect(editwindow_ui.pushButton_switch_mode,SIGNAL(clicked()),theclass,SLOT(switchMode()));
395 
396  adaptGuiForMode();
397 
398  connect(new QShortcut(QKeySequence(Qt::Key_Escape), editwindow),
399  SIGNAL(activated()),editwindow,SLOT(hide()));
400 
401 }

◆ previewEqualToLastApplied()

bool VP1MaterialButton::Imp::previewEqualToLastApplied ( ) const

Definition at line 604 of file VP1MaterialButton.cxx.

605 {
606  if (!editwindow)
607  return false;
608  return (equal(lastapplied_ambient,guiAmbientColour())
609  &&equal(lastapplied_diffuse,guiDiffuseColour())
610  &&equal(lastapplied_specular,guiSpecularColour())
611  &&equal(lastapplied_emissive,guiEmissiveColour())
612  &&lastapplied_shininess==guiShininess()
613  &&lastapplied_transparency==guiTransparency());
614 }

◆ printFloat()

QString VP1MaterialButton::Imp::printFloat ( const double &  d)
inline

Definition at line 93 of file VP1MaterialButton.cxx.

93  {
94  if (d==0)
95  return "0";
96  QString s = QString::number(d,'f',5);
97  while (s.right(1)=="0"&&s.contains("."))
98  s = s.left(s.count()-1);
99  if (s=="0.") return "0";
100  if (s=="1.") return "1";
101  return s;
102  }

◆ qcol2sbcol()

SbColor VP1MaterialButton::Imp::qcol2sbcol ( const QColor &  col)
static

Definition at line 499 of file VP1MaterialButton.cxx.

500 {
501  return SbColor( col.red()/255.0, col.green()/255.0, col.blue()/255.0 );
502 }

◆ sbcol2qcol()

QColor VP1MaterialButton::Imp::sbcol2qcol ( const SbColor &  col)
static

Definition at line 505 of file VP1MaterialButton.cxx.

506 {
507  float r,g,b;
508  col.getValue(r,g,b);
509  return QColor::fromRgbF( r,g,b );
510 }

◆ setLastAppliedFromCurrent()

void VP1MaterialButton::Imp::setLastAppliedFromCurrent ( )

Definition at line 586 of file VP1MaterialButton.cxx.

587 {
588  if (!editwindow)
589  return;
590  lastapplied_ambient = guiAmbientColour();
591  lastapplied_diffuse = guiDiffuseColour();
592  lastapplied_specular = guiSpecularColour();
593  lastapplied_emissive = guiEmissiveColour();
594  lastapplied_shininess = guiShininess();
595  lastapplied_transparency = guiTransparency();
596  lastapplied_brightness = std::max<int>(0,std::min<int>(100,static_cast<int>(100*brightnessEstimateFromDetailedParameters(lastapplied_diffuse,lastapplied_emissive)+0.5)));
597  updateApplyResetButtons();
598 
599  emit theclass->lastAppliedChanged();
600 
601 }

◆ simpleAmbient()

static QColor VP1MaterialButton::Imp::simpleAmbient ( )
inlinestatic

Definition at line 118 of file VP1MaterialButton.cxx.

118 { return QColor::fromRgbF(0.2,0.2,0.2); }

◆ simpleShininess()

static int VP1MaterialButton::Imp::simpleShininess ( )
inlinestatic

Definition at line 120 of file VP1MaterialButton.cxx.

120 { return 0; }

◆ simpleSpecular()

static QColor VP1MaterialButton::Imp::simpleSpecular ( )
inlinestatic

Definition at line 119 of file VP1MaterialButton.cxx.

119 { return Qt::black; }

◆ switchModeBasedOnLastApplied()

void VP1MaterialButton::Imp::switchModeBasedOnLastApplied ( )

Definition at line 716 of file VP1MaterialButton.cxx.

717 {
718  if (!editwindow)
719  return;
720 
721  bool lastappliedaresimple(false);
722 
723  if (lastapplied_shininess==simpleShininess()
724  &&equal(lastapplied_specular,simpleSpecular())
725  &&equal(lastapplied_ambient,simpleAmbient())) {
726  //Could be simple - test if emissive can be described as a
727  //brightness multiplied by diffusive:
728  double brightness = brightnessEstimateFromDetailedParameters(lastapplied_diffuse,lastapplied_emissive);
729  if (brightness<1.0e-4) {
730  lastappliedaresimple = equal(lastapplied_emissive,Qt::black);
731  } else if (brightness>(1.0-1.0e-4)) {
732  lastappliedaresimple = equal(lastapplied_emissive,lastapplied_diffuse);
733  } else {
734  lastappliedaresimple = equal(lastapplied_emissive,
735  emissiveColourFromSimpleParameters(lastapplied_diffuse, brightness));
736  }
737  }
738 
739  if (lastappliedaresimple!=simplemode)
740  theclass->switchMode();
741 }

◆ toSbColTxt()

QString VP1MaterialButton::Imp::toSbColTxt ( const QColor &  c)
inline

Definition at line 103 of file VP1MaterialButton.cxx.

103  { return "SbColor("+printFloat(c.redF())+","
104  +printFloat(c.greenF())+","+printFloat(c.blueF())+")";}

◆ updateApplyResetButtons()

void VP1MaterialButton::Imp::updateApplyResetButtons ( )

Definition at line 617 of file VP1MaterialButton.cxx.

618 {
619  if (!editwindow)
620  return;
621  if (previewEqualToLastApplied()) {
622  editwindow_ui.pushButton_apply->setEnabled(false);
623  editwindow_ui.pushButton_reset->setEnabled(false);
624  } else {
625  editwindow_ui.pushButton_apply->setEnabled(true);
626  editwindow_ui.pushButton_reset->setEnabled(true);
627  }
628 
629 }

Member Data Documentation

◆ blockcount

int VP1MaterialButton::Imp::blockcount

Definition at line 115 of file VP1MaterialButton.cxx.

◆ dim

int VP1MaterialButton::Imp::dim

Definition at line 56 of file VP1MaterialButton.cxx.

◆ dragStartPosition

QPoint VP1MaterialButton::Imp::dragStartPosition

Definition at line 52 of file VP1MaterialButton.cxx.

◆ editwindow

QWidget* VP1MaterialButton::Imp::editwindow

Definition at line 59 of file VP1MaterialButton.cxx.

◆ editwindow_ui

Ui::VP1MaterialButtonForm VP1MaterialButton::Imp::editwindow_ui

Definition at line 61 of file VP1MaterialButton.cxx.

◆ handledmaterials

QList<SoMaterial*> VP1MaterialButton::Imp::handledmaterials

Definition at line 68 of file VP1MaterialButton.cxx.

◆ lastapplied_ambient

QColor VP1MaterialButton::Imp::lastapplied_ambient

Definition at line 84 of file VP1MaterialButton.cxx.

◆ lastapplied_brightness

int VP1MaterialButton::Imp::lastapplied_brightness

Definition at line 90 of file VP1MaterialButton.cxx.

◆ lastapplied_diffuse

QColor VP1MaterialButton::Imp::lastapplied_diffuse

Definition at line 85 of file VP1MaterialButton.cxx.

◆ lastapplied_emissive

QColor VP1MaterialButton::Imp::lastapplied_emissive

Definition at line 87 of file VP1MaterialButton.cxx.

◆ lastapplied_shininess

int VP1MaterialButton::Imp::lastapplied_shininess

Definition at line 88 of file VP1MaterialButton.cxx.

◆ lastapplied_specular

QColor VP1MaterialButton::Imp::lastapplied_specular

Definition at line 86 of file VP1MaterialButton.cxx.

◆ lastapplied_transparency

int VP1MaterialButton::Imp::lastapplied_transparency

Definition at line 89 of file VP1MaterialButton.cxx.

◆ materialtext

QString VP1MaterialButton::Imp::materialtext

Definition at line 58 of file VP1MaterialButton.cxx.

◆ preview_material

SoMaterial* VP1MaterialButton::Imp::preview_material

Definition at line 60 of file VP1MaterialButton.cxx.

◆ previewswitch

SoSwitch* VP1MaterialButton::Imp::previewswitch

Definition at line 65 of file VP1MaterialButton.cxx.

◆ renderarea

SoQtRenderArea* VP1MaterialButton::Imp::renderarea

Definition at line 64 of file VP1MaterialButton.cxx.

◆ simplemode

bool VP1MaterialButton::Imp::simplemode

Definition at line 54 of file VP1MaterialButton.cxx.

◆ theclass

VP1MaterialButton* VP1MaterialButton::Imp::theclass

Definition at line 50 of file VP1MaterialButton.cxx.

The documentation for this class was generated from the following file:
VP1MaterialButton::Imp::theclass
VP1MaterialButton * theclass
Definition: VP1MaterialButton.cxx:50
VP1MaterialButton::Imp::simpleShininess
static int simpleShininess()
Definition: VP1MaterialButton.cxx:120
beamspotman.r
def r
Definition: beamspotman.py:676
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
color
Definition: jFexInputByteStreamTool.cxx:25
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
VP1MaterialButton::apply
void apply()
Definition: VP1MaterialButton.cxx:632
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
VP1MaterialButton::updatePreview
void updatePreview()
Definition: VP1MaterialButton.cxx:477
VP1MaterialButton::Imp::previewswitch
SoSwitch * previewswitch
Definition: VP1MaterialButton.cxx:65
max
#define max(a, b)
Definition: cfImp.cxx:41
VP1MaterialButton::Imp::setLastAppliedFromCurrent
void setLastAppliedFromCurrent()
Definition: VP1MaterialButton.cxx:586
VP1MaterialButton::transparencyChanged
void transparencyChanged()
Definition: VP1MaterialButton.cxx:682
VP1ExaminerViewer::removeDecorationMenuOption
virtual void removeDecorationMenuOption()
Definition: VP1ExaminerViewer.cxx:1377
VP1MaterialButton::Imp::guiDiffuseColour
QColor guiDiffuseColour() const
Definition: VP1MaterialButton.cxx:552
hist_file_dump.d
d
Definition: hist_file_dump.py:137
VP1MaterialButton::Imp::emissiveColourFromSimpleParameters
QColor emissiveColourFromSimpleParameters(const QColor &simpleColour, const double &brightness) const
Definition: VP1MaterialButton.cxx:528
VP1HelperClassBase::messageVerbose
void messageVerbose(const QString &) const
Definition: VP1HelperClassBase.cxx:78
fillPileUpNoiseLumi.connect
string connect
Definition: fillPileUpNoiseLumi.py:70
VP1MaterialButton::Imp::lastapplied_transparency
int lastapplied_transparency
Definition: VP1MaterialButton.cxx:89
VP1MaterialButton::Imp::preview_material
SoMaterial * preview_material
Definition: VP1MaterialButton.cxx:60
VP1MaterialButton::Imp::lastapplied_diffuse
QColor lastapplied_diffuse
Definition: VP1MaterialButton.cxx:85
VP1MaterialButton::Imp::guiShininess
int guiShininess() const
Definition: VP1MaterialButton.cxx:580
VP1MaterialButton::Imp::guiEmissiveColour
QColor guiEmissiveColour() const
Definition: VP1MaterialButton.cxx:564
VP1MaterialButton::Imp::distSq
static double distSq(const QColor &a, const QColor &b)
Definition: VP1MaterialButton.cxx:513
VP1MaterialButton::Imp::lastapplied_emissive
QColor lastapplied_emissive
Definition: VP1MaterialButton.cxx:87
athena.value
value
Definition: athena.py:122
VP1MaterialButton::Imp::lastapplied_ambient
QColor lastapplied_ambient
Definition: VP1MaterialButton.cxx:84
VP1MaterialButton::Imp::brightnessEstimateFromDetailedParameters
double brightnessEstimateFromDetailedParameters(const QColor &diffuseColour, const QColor &emissiveColour) const
Definition: VP1MaterialButton.cxx:536
VP1ExaminerViewer::setTransparencyType
virtual void setTransparencyType(SoGLRenderAction::TransparencyType)
Definition: VP1ExaminerViewer.cxx:1731
VP1MaterialButton::Imp::equal
static bool equal(const QColor &a, const QColor &b, const double &tol=1.0e-6)
Definition: VP1MaterialButton.cxx:522
VP1String::str
static QString str(const QString &s)
Definition: VP1String.h:49
LINES
bool LINES
Definition: computils.cxx:39
VP1MaterialButton::Imp::blockcount
int blockcount
Definition: VP1MaterialButton.cxx:115
VP1ExaminerViewer::viewAll
virtual void viewAll()
Definition: VP1ExaminerViewer.cxx:1457
VP1MaterialButton::Imp::guiAmbientColour
QColor guiAmbientColour() const
Definition: VP1MaterialButton.cxx:546
VP1MaterialButton::Imp::editwindow_ui
Ui::VP1MaterialButtonForm editwindow_ui
Definition: VP1MaterialButton.cxx:61
VP1MaterialButton::Imp::printFloat
QString printFloat(const double &d)
Definition: VP1MaterialButton.cxx:93
checkTP.save
def save(self, fileName="./columbo.out")
Definition: checkTP.py:178
VP1MaterialButton::Imp::guiSpecularColour
QColor guiSpecularColour() const
Definition: VP1MaterialButton.cxx:558
VP1MaterialButton::Imp::initEditWindow
void initEditWindow()
Definition: VP1MaterialButton.cxx:307
VP1QtUtils::environmentVariableIsOn
static bool environmentVariableIsOn(const QString &name)
Definition: VP1QtUtils.cxx:127
VP1MaterialButton::Imp::adaptGuiForMode
void adaptGuiForMode()
Definition: VP1MaterialButton.cxx:703
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
VP1MaterialButton::Imp::lastapplied_specular
QColor lastapplied_specular
Definition: VP1MaterialButton.cxx:86
VP1MaterialButton::Imp::switchModeBasedOnLastApplied
void switchModeBasedOnLastApplied()
Definition: VP1MaterialButton.cxx:716
VP1QtUtils::expertSettingIsOn
static bool expertSettingIsOn(const QString &type, const QString &name)
Definition: VP1QtUtils.cxx:60
VP1MaterialButton::Imp::blockGuiSignals
void blockGuiSignals(bool)
Definition: VP1MaterialButton.cxx:280
VP1MaterialButton::updatePreviewSceneAndBgd
void updatePreviewSceneAndBgd()
Definition: VP1MaterialButton.cxx:487
VP1MaterialButton::Imp::previewEqualToLastApplied
bool previewEqualToLastApplied() const
Definition: VP1MaterialButton.cxx:604
VP1MaterialButton::lastAppliedChanged
void lastAppliedChanged()
min
#define min(a, b)
Definition: cfImp.cxx:40
VP1MaterialButton::Imp::guiTransparency
int guiTransparency() const
Definition: VP1MaterialButton.cxx:573
VP1MaterialButton::Imp::updateApplyResetButtons
void updateApplyResetButtons()
Definition: VP1MaterialButton.cxx:617
VP1MaterialButton::Imp::renderarea
SoQtRenderArea * renderarea
Definition: VP1MaterialButton.cxx:64
python.selection.number
number
Definition: selection.py:20
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
VP1MaterialButton::Imp::lastapplied_brightness
int lastapplied_brightness
Definition: VP1MaterialButton.cxx:90
VP1MaterialButton::Imp::simpleAmbient
static QColor simpleAmbient()
Definition: VP1MaterialButton.cxx:118
query_example.col
col
Definition: query_example.py:7
VP1MaterialButton::reset
void reset()
Definition: VP1MaterialButton.cxx:641
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
VP1MaterialButton::Imp::lastapplied_shininess
int lastapplied_shininess
Definition: VP1MaterialButton.cxx:88
VP1MaterialButton::Imp::simplemode
bool simplemode
Definition: VP1MaterialButton.cxx:54
VP1MaterialButton::switchMode
void switchMode()
Definition: VP1MaterialButton.cxx:745
VP1Msg::verbose
static bool verbose()
Definition: VP1Msg.h:31
VP1MaterialButton::Imp::simpleSpecular
static QColor simpleSpecular()
Definition: VP1MaterialButton.cxx:119
VP1MaterialButton::Imp::editwindow
QWidget * editwindow
Definition: VP1MaterialButton.cxx:59
VP1MaterialButton::Imp::qcol2sbcol
static SbColor qcol2sbcol(const QColor &)
Definition: VP1MaterialButton.cxx:499
python.compressB64.c
def c
Definition: compressB64.py:93
VP1ExaminerViewer
Definition: VP1ExaminerViewer.h:30
Generated on Thu Jul 4 2024 22:09:34 for ATLAS Offline Software by   doxygen 1.8.18