InbandTextTrack::InbandTextTrack(WebInbandTextTrack* webTrack)
: TextTrack(emptyAtom, webTrack->label(), webTrack->language(), webTrack->id(), InBand)
, m_webTrack(webTrack)
{
m_webTrack->setClient(this);
switch (m_webTrack->kind()) {
case WebInbandTextTrack::KindSubtitles:
setKind(TextTrack::subtitlesKeyword());
break;
case WebInbandTextTrack::KindCaptions:
setKind(TextTrack::captionsKeyword());
break;
case WebInbandTextTrack::KindDescriptions:
setKind(TextTrack::descriptionsKeyword());
break;
case WebInbandTextTrack::KindChapters:
setKind(TextTrack::chaptersKeyword());
break;
case WebInbandTextTrack::KindMetadata:
setKind(TextTrack::metadataKeyword());
break;
case WebInbandTextTrack::KindNone:
default:
ASSERT_NOT_REACHED();
break;
}
}
InbandTextTrack::InbandTextTrack(ScriptExecutionContext* context, TextTrackClient* client, PassRefPtr<InbandTextTrackPrivate> tracksPrivate)
: TextTrack(context, client, emptyString(), tracksPrivate->label(), tracksPrivate->language(), InBand)
, m_private(tracksPrivate)
{
m_private->setClient(this);
switch (tracksPrivate->kind()) {
case InbandTextTrackPrivate::subtitles:
setKind(TextTrack::subtitlesKeyword());
break;
case InbandTextTrackPrivate::captions:
setKind(TextTrack::captionsKeyword());
break;
case InbandTextTrackPrivate::descriptions:
setKind(TextTrack::descriptionsKeyword());
break;
case InbandTextTrackPrivate::chapters:
setKind(TextTrack::chaptersKeyword());
break;
case InbandTextTrackPrivate::metadata:
setKind(TextTrack::metadataKeyword());
break;
case InbandTextTrackPrivate::none:
default:
ASSERT_NOT_REACHED();
break;
}
}
void ofxUITextArea::init(string _name, string _textstring, float w, float h, float x, float y, int _size)
{
initRect(x,y,w,h);
setName(_name);
setKind(OFX_UI_WIDGET_TEXTAREA);
textstring = _textstring;
setDrawFill(true);
setDrawBack(false);
drawShadow = false;
drawLabel = false;
label = new ofxUILabel(padding*2.0,0,(name+" LABEL"), _size);
addEmbeddedWidget(label);
label->setVisible(drawLabel);
if(h == 0)
{
autoSize = true;
}
else
{
autoSize = false;
}
}
void Pockels::_set_config( Config IN *cfg )
{ _config = cfg;
setKind(cfg->kind());
Guarded_Assert(_nidaq||_simulated); // at least one device was instanced
if(_nidaq) _nidaq->_set_config(cfg->mutable_nidaq());
if(_simulated) _simulated->_set_config(cfg->mutable_simulated());
}
Feed::Feed(RootItem *parent)
: RootItem(parent), m_url(QString()), m_status(Normal), m_autoUpdateType(DefaultAutoUpdate),
m_autoUpdateInitialInterval(DEFAULT_AUTO_UPDATE_INTERVAL), m_autoUpdateRemainingInterval(DEFAULT_AUTO_UPDATE_INTERVAL),
m_totalCount(0), m_unreadCount(0) {
setKind(RootItemKind::Feed);
setAutoDelete(false);
}
void VideoTrackPrivateAVFObjC::resetPropertiesFromTrack()
{
setSelected(m_impl->enabled());
setKind(m_impl->videoKind());
setId(m_impl->id());
setLabel(m_impl->label());
setLanguage(m_impl->language());
}
NamespaceAliasDeclaration::NamespaceAliasDeclaration(const SimpleRange& range, DUContext* context)
: Declaration(*new NamespaceAliasDeclarationData, range)
{
d_func_dynamic()->setClassId(this);
setKind(NamespaceAlias);
if( context )
setContext( context );
}
void BuildInfoJSON::fromJSONKind(JSONValue *json_value, bool ignore_extras)
{
assert(json_value != NULL);
const JSONStringValue *json_string = json_value->string_value();
if (json_string == NULL)
throw("The value for field Kind of BuildInfoJSON is not a string.");
setKind(std::string(json_string->getData()));
}
AliasDeclaration::AliasDeclaration(const RangeInRevision& range, DUContext* context)
: ClassMemberDeclaration(*new AliasDeclarationData, range)
{
d_func_dynamic()->setClassId(this);
setKind(Alias);
if( context )
setContext( context );
}
void AudioTrack::updateKindFromPrivate()
{
switch (m_private->kind()) {
case AudioTrackPrivate::Alternative:
setKind(AudioTrack::alternativeKeyword());
break;
case AudioTrackPrivate::Description:
setKind(AudioTrack::descriptionKeyword());
break;
case AudioTrackPrivate::Main:
setKind(AudioTrack::mainKeyword());
break;
case AudioTrackPrivate::MainDesc:
setKind(AudioTrack::mainDescKeyword());
break;
case AudioTrackPrivate::Translation:
setKind(AudioTrack::translationKeyword());
break;
case AudioTrackPrivate::Commentary:
setKind(AudioTrack::commentaryKeyword());
break;
case AudioTrackPrivate::None:
setKind(emptyString());
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
Pockels::Pockels( Agent *agent, Config *cfg )
:PockelsBase<cfg::device::Pockels>(agent,cfg)
,_nidaq(NULL)
,_simulated(NULL)
,_idevice(NULL)
,_ipockels(NULL)
{
setKind(cfg->kind());
}
void AudioTrackPrivateMediaSourceAVFObjC::resetPropertiesFromTrack()
{
m_trackID = m_impl->trackID();
setKind(m_impl->audioKind());
setId(m_impl->id());
setLabel(m_impl->label());
setLanguage(m_impl->language());
}
DAQ::DAQ( Agent *agent, Config *cfg )
:DAQBase<Config>(agent,cfg)
,_nidaq(NULL)
,_simulated(NULL)
,_idevice(NULL)
,_idaq(NULL)
{
setKind(_config->kind());
}
void ofxUISlider_<T>::init(string _name, T _min, T _max, T *_value, float w, float h, float x, float y)
{
initRect(x,y,w,h);
name = string(_name);
setOrientation(w, h);
setKind();
draw_fill = true;
value = *_value; //the widget's value
if(useReference)
{
valueRef = _value;
}
else
{
valueRef = new T();
*valueRef = value;
}
max = _max;
min = _min;
labelPrecision = 2;
if(value > max)
{
value = max;
}
if(value < min)
{
value = min;
}
value = ofxUIMap(value, min, max, 0.0, 1.0, true);
valueString = ofxUIToString(getScaledValue(),labelPrecision);
if(orientation == OFX_UI_ORIENTATION_HORIZONTAL)
{
label = new ofxUILabel(0,h+padding,string(name+" LABEL"), string(name + ": " + ofxUIToString(max,labelPrecision)), OFX_UI_FONT_SMALL);
}
else
{
label = new ofxUILabel(0,h+padding,string(name+" LABEL"), string(name), OFX_UI_FONT_SMALL);
}
addEmbeddedWidget(label);
label->setVisible(drawLabel);
increment = ABS(max - min) / 100.0;
bRoundedToNearestInt = false;
bClampValue = true;
bSticky = false;
stickyValue = MAX(10.0*ceil(increment), 1.0);
warp = 1.0;
setInternalValueFromValue();
}
CastExpression::CastExpression(int lno, int ct, Expression *arg) {
setKind(ECAST);
setLineNo(lno);
castTo = ct;
setType(0); // set as the default expression type
if (arg != NULL)
operand = arg;
else
throw AstException("CastExpression::CastExpression: NULL arg\n");
}
void VideoTrackPrivateAVFObjC::resetPropertiesFromTrack()
{
// Don't call this->setSelected() because it also sets the enabled state of the
// AVPlayerItemTrack
VideoTrackPrivateAVF::setSelected(m_impl->enabled());
setKind(m_impl->videoKind());
setId(m_impl->id());
setLabel(m_impl->label());
setLanguage(m_impl->language());
}
AssignStatement::AssignStatement( int lno, const char *name, Expression *rhs )
{
setKind( SASSIGN );
setLineNo( lno );
lhsName = name;
entry = NULL;
index = NULL;
if( rhs != NULL )
expr = rhs;
else
throw AstException( "AssignStatement::AssignStatement: NULL rhs expression\n" );
}
////////////////////////////////////////////////////////////////////////////////
//initialise, finalise, uodate
MtxLP::MtxLP(bool max, int kind, int msg_lev, int tm_lim, int it_lim, string name){
createProb();
setObjDir(max);
setKind(kind);
setName(name);
this->ret_cod = 0;
this->vmax = 1;
this->msg_lev = msg_lev;
this->tm_lim = tm_lim;
this->it_lim = it_lim;
this->mip_gap = MIP_GAP;
}
void ComputerPlane::compinit()
{
x=(float)(rand()%500-250);
y=(float)(rand()%100+300);
direction=(float)(rand()%90-135);
blastNum=0;
explosible=false;
#ifdef TEST_ENEMY
setKind(2);
#else
int temp=rand()%8;
if(temp<=4)
setKind(0);
else if(temp==5 || temp==6)
setKind(1);
else if(temp==7)
setKind(2);
#endif
}
TextTrack::TextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, const AtomicString& id, TextTrackType type)
: TrackBase(TrackBase::TextTrack, label, language, id)
, m_cues(nullptr)
, m_regions(nullptr)
, m_trackList(nullptr)
, m_mode(disabledKeyword())
, m_trackType(type)
, m_readinessState(NotLoaded)
, m_trackIndex(invalidTrackIndex)
, m_renderedTrackIndex(invalidTrackIndex)
, m_hasBeenConfigured(false)
{
setKind(kind);
}
BinaryExpression::BinaryExpression( int lno, int op, Expression *left, Expression *right )
{
setKind( EBINARY );
setLineNo( lno );
oper = op;
setType( 0 ); // set as the default expression type
if( left != NULL )
leftOperand = left;
else
throw AstException( "BinaryExpression::BinaryExpression: NULL left operand\n" );
if( right != NULL )
rightOperand = right;
else
throw AstException( "BinaryExpression::BinaryExpression: NULL right operand\n" );
}
TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const AtomicString& kind, const AtomicString& label, const AtomicString& language, TextTrackType type)
: TrackBase(context, TrackBase::TextTrack)
, m_cues(0)
, m_mediaElement(0)
, m_label(label)
, m_language(language)
, m_mode(disabledKeyword().string())
, m_client(client)
, m_trackType(type)
, m_readinessState(NotLoaded)
, m_showingByDefault(false)
, m_trackIndex(invalidTrackIndex)
{
setKind(kind);
}
MojErr MojDbSearchCache::QueryKey::setQuery(const MojDbQuery& query)
{
MojObject obj;
MojErr err = query.toObject(obj);
MojErrCheck(err);
bool foundOut=false;
obj.del(MojDbQuery::PageKey, foundOut);
obj.del(MojDbQuery::LimitKey, foundOut);
err = obj.toJson(m_query);
MojErrCheck(err);
setKind(query.from());
return err;
}
TextTrack::TextTrack(Document& document, const AtomicString& kind, const AtomicString& label, const AtomicString& language, const AtomicString& id, TextTrackType type)
: TrackBase(TrackBase::TextTrack, label, language, id)
, m_cues(nullptr)
, m_regions(nullptr)
, m_document(&document)
, m_trackList(0)
, m_mode(disabledKeyword())
, m_trackType(type)
, m_readinessState(NotLoaded)
, m_trackIndex(invalidTrackIndex)
, m_renderedTrackIndex(invalidTrackIndex)
, m_hasBeenConfigured(false)
{
ScriptWrappable::init(this);
setKind(kind);
}
void DAQ::_set_config( const Config &cfg )
{
cfg::device::DAQ_DAQKind kind = cfg.kind();
_config->set_kind(kind);
setKind(kind);
switch(kind)
{
case cfg::device::DAQ_DAQKind_NIDAQ:
_nidaq->_set_config(cfg.nidaq());
break;
case cfg::device::DAQ_DAQKind_Simulated:
_simulated->_set_config(cfg.simulated());
break;
default:
error("Unrecognized kind() for DAQ. Got: %u\r\n",(unsigned)kind);
}
}
IfStatement::IfStatement( int lno, Expression *e, Statement *ts, Statement *es )
{
setKind( SIF );
setLineNo( lno );
if( e != NULL )
expr = e;
else
throw AstException( "IfStatement::IfStatement: NULL expression\n" );
if( ts != NULL )
thenStmt = ts;
else
throw AstException( "IfStatement::IfStatement: NULL then statement node\n" );
elseStmt = es;
}
void Pockels::_set_config( const Config &cfg )
{
cfg::device::Pockels_PockelsType kind = cfg.kind();
_config->set_kind(kind);
setKind(kind);
switch(kind)
{
case cfg::device::Pockels_PockelsType_NIDAQ:
_nidaq->_set_config(const_cast<Config&>(cfg).mutable_nidaq());
break;
case cfg::device::Pockels_PockelsType_Simulated:
_simulated->_set_config(cfg.simulated());
break;
default:
error("Unrecognized kind() for Pockels. Got: %u\r\n",(unsigned)kind);
}
}
TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const AtomicString& kind, const AtomicString& id, const AtomicString& label, const AtomicString& language, TextTrackType type)
: TrackBase(TrackBase::TextTrack, id, label, language)
, m_cues(0)
, m_scriptExecutionContext(context)
#if ENABLE(WEBVTT_REGIONS)
, m_regions(0)
#endif
, m_mode(disabledKeyword().string())
, m_client(client)
, m_trackType(type)
, m_readinessState(NotLoaded)
, m_trackIndex(invalidTrackIndex)
, m_renderedTrackIndex(invalidTrackIndex)
, m_hasBeenConfigured(false)
{
setKind(kind);
}
void TextTrack::setKindKeywordIgnoringASCIICase(StringView keyword)
{
if (equalLettersIgnoringASCIICase(keyword, "captions"))
setKind(Kind::Captions);
else if (equalLettersIgnoringASCIICase(keyword, "chapters"))
setKind(Kind::Chapters);
else if (equalLettersIgnoringASCIICase(keyword, "descriptions"))
setKind(Kind::Descriptions);
else if (equalLettersIgnoringASCIICase(keyword, "forced"))
setKind(Kind::Forced);
else if (equalLettersIgnoringASCIICase(keyword, "metadata"))
setKind(Kind::Metadata);
else if (equalLettersIgnoringASCIICase(keyword, "subtitles"))
setKind(Kind::Subtitles);
#if !ENABLE(MEDIA_SOURCE)
// FIXME: This preserves the behavior of an older version of this code before refactoring.
// !ENABLE(MEDIA_SOURCE): unknown keywords all get turned into Subtitles.
// ENABLE(MEDIA_SOURCE): unknown keywords leave the old value for kind untouched.
// I am not sure that either of those is the correct behavior; should test and fix.
else
setKind(Kind::Subtitles);
#endif
}
VideoTrack::VideoTrack(VideoTrackClient* client, PassRefPtr<VideoTrackPrivate> trackPrivate)
: TrackBase(TrackBase::VideoTrack, trackPrivate->label(), trackPrivate->language())
, m_id(trackPrivate->id())
, m_selected(trackPrivate->selected())
, m_client(client)
, m_private(trackPrivate)
{
m_private->setClient(this);
switch (m_private->kind()) {
case VideoTrackPrivate::Alternative:
setKind(VideoTrack::alternativeKeyword());
break;
case VideoTrackPrivate::Captions:
setKind(VideoTrack::captionsKeyword());
break;
case VideoTrackPrivate::Main:
setKind(VideoTrack::mainKeyword());
break;
case VideoTrackPrivate::Sign:
setKind(VideoTrack::signKeyword());
break;
case VideoTrackPrivate::Subtitles:
setKind(VideoTrack::subtitlesKeyword());
break;
case VideoTrackPrivate::Commentary:
setKind(VideoTrack::commentaryKeyword());
break;
case VideoTrackPrivate::None:
setKind(emptyString());
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
