Set those settings needed for the detailed display

@param \Gems_Tracker_Engine_TrackEngineInterface $trackEngine
@param boolean $edit When true the fields are added in edit mode
@return \Gems_Model_RespondentTrackModel
336121
public function applyDetailSettings(\Gems_Tracker_Engine_TrackEngineInterface $trackEngine, $edit = false)
    {
        $this->resetOrder();

        $translated = $this->util->getTranslated();
        $formatDate = $this->util->getTranslated()->formatDate;

        $this->set('gr2o_patient_nr',   'label', $this->_('Respondent number'));
        $this->set('respondent_name',   'label', $this->_('Respondent name'));
        $this->set('gtr_track_name',    'label', $this->_('Track'));

        $this->set('gr2t_mailable',
                'label', $this->_('May be mailed'),
                'elementClass', 'radio',
                'separator', ' ',
                'multiOptions', array(
                        '1' => $this->_('Yes'),
                        '0' => $this->_('No'),
                    )
                );

        $this->set('assigned_by',          'label', $this->_('Assigned by'));
        $this->set('gr2t_start_date',      'label', $this->_('Start'),
            'dateFormat', 'dd-MM-yyyy',
            'formatFunction', $formatDate);

        // Integrate fields
        $trackEngine->addFieldsToModel($this, $edit);

        $this->set('gr2t_end_date_manual', 'label', $this->_('Set ending on'),
                'description', $this->_('Manually set dates are fixed an will never be (re)calculated.'),
                'elementClass', 'Radio',
                'multiOptions', $translated->getDateCalculationOptions(),
                'separator', ' '
                );
        $this->set('gr2t_end_date',        'label', $this->_('Ending on'),
            'dateFormat', 'dd-MM-yyyy',
            'formatFunction', $formatDate);
        $this->set('gr2t_track_info',      'label', $this->_('Description'));
        $this->set('gr2t_comment',         'label', $this->_('Comment'));
        $this->set('grc_description',      'label', $this->_('Reception code'),
                'elementClass', 'Exhibitor');
        $this->refreshGroupSettings();

        return $this;
    }
1092404
public function trackView()
    {
        if ($this->ID > 0) {
            $count = $this->ViewCount + 1;

            $this->ViewCount = $count;

            DB::query("UPDATE \"DMSDocument\" SET \"ViewCount\"='$count' WHERE \"ID\"={$this->ID}");

            $this->extend('trackView');
        }

        return $this;
    }
591340
public synchronized void updateFromTrackParameters(TrackParameters track) {
    parameters.clear();
    for(TrackedParameter p : track.getAllParameters()) {
      Parameter<?> option = p.getParameter();
      String value = null;
      if(option.isDefined()) {
        if(option.tookDefaultValue()) {
          value = DynamicParameters.STRING_USE_DEFAULT + option.getDefaultValueAsString();
        }
        else {
          value = option.getValueAsString();
        }
      }
      if(value == null) {
        value = (option instanceof Flag) ? Flag.NOT_SET : "";
      }
      int bits = 0;
      if(option.isOptional()) {
        bits |= BIT_OPTIONAL;
      }
      if(option.hasDefaultValue() && option.tookDefaultValue()) {
        bits |= BIT_DEFAULT_VALUE;
      }
      if(value.length() <= 0) {
        if((bits & BIT_DEFAULT_VALUE) == 0 && (bits & BIT_OPTIONAL) == 0) {
          bits |= BIT_INCOMPLETE;
        }
      }
      else {
        try {
          if(!option.tookDefaultValue() && !option.isValid(value)) {
            bits |= BIT_INVALID;
          }
        }
        catch(ParameterException e) {
          bits |= BIT_INVALID;
        }
      }
      int depth = 0;
      {
        Object pos = track.getParent(option);
        while(pos != null) {
          pos = track.getParent(pos);
          depth += 1;
          if(depth > 10) {
            break;
          }
        }
      }
      parameters.add(new Node(option, value, bits, depth));
    }
  }
1248775
public function forget(TrackableInterface $trackable)
    {
        foreach ($this->getTrackerGenerator() as $tracker) {
            $tracker->forget($trackable);
        }

        return $this;
    }
431778
def setEditorData( self, editor, index ):
        
        item        = self.parent().itemFromIndex(index)
        value       = item.value()
        tree        = self.parent()
        querywidget = tree.parent()
        factory     = querywidget.factory()
        
        factory.setEditorData(editor, value)
387512
public function edit(SettingUpdateListener $listener)
    {
        $memory = $this->memory;

        $eloquent = new Fluent([
            'mode' => $memory->get('site.mode', 'development')
        ]);

        $form = $this->presenter->form($eloquent);
        return $listener->showSettingChanger(compact('eloquent', 'form'));
    }
476606
public function forget(TrackableInterface $trackable)
    {
        if ($trackable instanceof Collection) {
            $this->forgetCollection($trackable);
        }

        if ($trackable instanceof PageController) {
            $this->forgetCollection($trackable->getPageObject());
        }

        if ($trackable instanceof Controller) {
            // Delete all blocks with this id
            $this->manager->createQueryBuilder()
                ->delete(StackUsageRecord::class, 'r')
                ->where('r.block_id = :block_id')
                ->setParameter('block_id', $trackable->getBlockObject()->getBlockID())
                ->getQuery()->execute();
        }
    }
450760
protected function getViewTrackTitle()
    {
        $trackEngine = $this->getTrackEngine();

        if ($this->isMultiTracks()) {
            $respondent = $this->getRespondent();

            // Set params
            return sprintf(
                    $this->_('%s track assignments for respondent nr %s: %s'),
                    $trackEngine->getTrackName(),
                    $this->_getParam(\MUtil_Model::REQUEST_ID1),
                    $this->getRespondent()->getFullName()
                    );
        } else {
            return sprintf(
                    $this->_('%s track overview'),
                    $trackEngine->getTrackName()
                    );
        }
    }
188299
public function execute($trackId = null, $exportOrganizations = false)
    {
        $batch = $this->getBatch();
        $data  = $this->db->fetchRow("SELECT * FROM gems__tracks WHERE gtr_id_track = ?", $trackId);
        $orgs  = $exportOrganizations ? $data['gtr_organizations'] : false;

        unset($data['gtr_id_track'], $data['gtr_track_type'], $data['gtr_active'], $data['gtr_survey_rounds'], $data['gtr_organizations'],
                $data['gtr_changed'],
                $data['gtr_changed_by'], $data['gtr_created'], $data['gtr_created_by']);

        // Main track data
        $this->exportTypeHeader('track');
        $this->exportFieldHeaders($data);
        $this->exportFieldData($data);

        if ($orgs) {
            // Organizations
            $this->exportTypeHeader('organizations');
            $this->exportFieldHeaders(array('gor_id_organization' => null, 'gor_name' => null));
            foreach (explode('|', $orgs) as $orgId) {
                if ($orgId) {
                    $org = $this->loader->getOrganization($orgId);
                    if ($org) {
                        $this->exportFieldData(array($orgId, $org->getName()));
                    }
                }
            }
            $batch->addMessage($this->_('Trackdata exported with organizations.'));
        } else {
            $batch->addMessage($this->_('Trackdata exported without organizations.'));
        }

        $this->exportFlush();
    }
875692
public void setTuneAndTemplate(Tune tune, ScoreTemplate template) {
		//from setTemplate(template)
		if (m_template != null)
			m_template.removeListener(this);
		m_template = template;
		m_template.setGraphics(getGraphics2D());
		m_template.addListener(this);
		//from refresh()
		initGfx();
		setTune(tune);
	}
1040406
public function processBeforeSave(array $fieldData, array $trackData)
    {
        $this->changed = false;

        if (! $this->exists) {
            return null;
        }

        foreach ($this->_fields as $key => $field) {
            if ($field instanceof FieldInterface) {
                $field->calculationStart($trackData);
            }
        }

        $output = array();

        foreach ($this->_fields as $key => $field) {
            if ($field instanceof FieldInterface) {
                $inVal  = isset($fieldData[$key]) ? $fieldData[$key] : null;
                $outVal = $field->calculateFieldValue($inVal, $fieldData, $trackData);

                if (is_array($outVal) || is_array($inVal)) {
                   if (is_array($outVal) && is_array($inVal)) {
                        $changedNow = ($outVal != $inVal);
                    } else {
                        $changedNow = true;
                    }
                } else {
                    $changedNow = ((string) $inVal !== (string) $outVal);
                }
                $this->changed = $this->changed || $changedNow;

                $fieldData[$key] = $outVal; // Make sure the new value is available to the next field
                $output[$key]    = $outVal;
            }
        }

        return $output;
    }
304600
public function updateTrackCode(Model $order, UpdateTrackCodeRequest $request)
    {
        $order->update(['track_code' => $request->track_code]);

        //Mail::to($userEmail)->send(new UpdateOrderStatusMail($orderStatusTitle));

        return redirect()->route('admin.order.index');
    }
1374407
function engineManager_editKeyword(name, handler)
  {
    // Select the search engine
    this.selectedEngine = name;

    // Setup the modal dialog handler
    md = new modalDialog.modalDialog(this._controller.window);
    md.start(handler);

    var button = this.getElement({type: "engine_button", subtype: "edit"});
    this._controller.click(button);
    md.waitForDialog();
  }
1155227
public void propertyChange(java.beans.PropertyChangeEvent evt)
    {
        if (evt.getPropertyName().equals(this.editorKey))
        {
            this.setValue(evt.getNewValue());
        }
    }
626681
protected function applicationForm(Fieldset $fieldset, Fluent $model): void
    {
        $fieldset->control('text', 'site_name')
            ->label(\trans('orchestra/foundation::label.name'))
            ->value(\data_get($model, 'site.name'))
            ->attributes(['autocomplete' => 'off']);
    }
920335
public void setTrackStart(final double TRACK_START) {
        // check values
        if (Double.compare(TRACK_START, trackStop) == 0) {
            throw new IllegalArgumentException("Track start value cannot equal track stop value");
        }
        trackStart = TRACK_START;
        validate();
        fireStateChanged();
    }
648468
public function processChangedRespondent(\Gems_Tracker_Respondent $respondent)
    {
        $changes    = 0;
        $tracker    = $this->loader->getTracker();
        $respTracks = $tracker->getRespondentTracks($respondent->getId(), $respondent->getOrganizationId());
        $userId     = $this->currentUser->getUserId();

        $tracksData = $this->db->fetchAll("SELECT * FROM gems__tracks
            WHERE gtr_active = 1 AND
                CONCAT(' ', gtr_code, ' ') LIKE '% " . $this->trackCode . " %' AND
                gtr_organizations LIKE '%|" . $respondent->getOrganizationId() . "|%'
            ORDER BY gtr_track_name");

        // \MUtil_Echo::track($tracksData);

        $changes = false;

        foreach ($tracksData as $trackData) {
            $trackEngine = $tracker->getTrackEngine($trackData);
            if ($trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) {
                // \MUtil_Echo::track($trackEngine->getTrackCode(), count($respTracks));

                $create = true;
                foreach($respTracks as $respondentTrack) {
                    if (($respondentTrack instanceof \Gems_Tracker_RespondentTrack) &&
                            ($respondentTrack->getTrackId() == $trackEngine->getTrackId())) {
                        $create = false;
                        break;
                    }
                }

                // \MUtil_Echo::track($create);
                if ($create) {
                    $changes = true;
                    $tracker->createRespondentTrack(
                            $respondent->getId(),
                            $respondent->getOrganizationId(),
                            $trackEngine->getTrackId(),
                            $userId
                            );
                }
            }
        }

        return $changes;
    }