// Phonon::MediaSource* MediaSource(Phonon::MediaSourcePrivate& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Creates an empty MediaSource.
/// An empty MediaSource is considered valid and can be set on a MediaObject to unload its
/// current media.
/// \see Empty
/// </remarks> <short> Creates an empty MediaSource.</short>
public MediaSource() : this((Type)null)
{
CreateProxy();
interceptor.Invoke("MediaSource", "MediaSource()", typeof(void));
}
// Phonon::Effect* insertEffect(const Phonon::ObjectDescription<Phonon::EffectType>& arg1,Phonon::Effect* arg2); >>>> NOT CONVERTED
// Phonon::Effect* insertEffect(const Phonon::ObjectDescription<Phonon::EffectType>& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Creates an invalid path.
/// You can still make it a valid path by calling reconnect. To create a path you should use
/// createPath, though.
/// \see createPath
/// \see isValid
/// </remarks> <short> Creates an invalid path.</short>
public Path() : this((Type)null)
{
CreateProxy();
interceptor.Invoke("Path", "Path()", typeof(void));
}
public static bool operator==(MediaSource lhs, Phonon.MediaSource rhs)
{
return((bool)staticInterceptor.Invoke("operator==#", "operator==(const Phonon::MediaSource&) const", typeof(bool), typeof(MediaSource), lhs, typeof(Phonon.MediaSource), rhs));
}
public Blitz() : this((Type)null)
{
CreateProxy();
interceptor.Invoke("Blitz", "Blitz()", typeof(void));
}
public static bool operator==(Path lhs, Phonon.Path p)
{
return((bool)staticInterceptor.Invoke("operator==#", "operator==(const Phonon::Path&) const", typeof(bool), typeof(Path), lhs, typeof(Phonon.Path), p));
}
// char* toString(const void* arg1); >>>> NOT CONVERTED
// void ignoreMessage(QtMsgType arg1,const char* arg2); >>>> NOT CONVERTED
// void* qData(const char* arg1,int arg2); >>>> NOT CONVERTED
// void* qGlobalData(const char* arg1,int arg2); >>>> NOT CONVERTED
// void* qElementData(const char* arg1,int arg2); >>>> NOT CONVERTED
// bool compare_ptr_helper(const void* arg1,const void* arg2,const char* arg3,const char* arg4,const char* arg5,int arg6); >>>> NOT CONVERTED
public static Pointer <sbyte> ToHexRepresentation(string ba, int length)
{
return((Pointer <sbyte>)staticInterceptor.Invoke("toHexRepresentation$$", "toHexRepresentation(const char*, int)", typeof(Pointer <sbyte>), typeof(string), ba, typeof(int), length));
}
/// <remarks>
/// Returns the name of the capture source.
/// \return A string that should be presented to the user to
/// choose the capture source.
/// </remarks> <short> Returns the name of the capture source.</short>
public string Name()
{
return((string)interceptor.Invoke("name", "name() const", typeof(string)));
}
/// <remarks>
/// \internal
/// Creates an invalid effect parameter.
/// </remarks> <short> \internal </short>
public EffectParameter() : this((Type)null)
{
CreateProxy();
interceptor.Invoke("EffectParameter", "EffectParameter()", typeof(void));
}
// QList<QsciCommand*>& commands(); >>>> NOT CONVERTED
public bool ReadSettings(QSettings qs, string prefix)
{
return((bool)interceptor.Invoke("readSettings#$", "readSettings(QSettings&, const char*)", typeof(bool), typeof(QSettings), qs, typeof(string), prefix));
}
/// <remarks>
/// Call this function from the constructor of your StreamInterface implementation (or as
/// soon as you get the MediaSource object). This will connect your object to the
/// AbstractMediaStream object. Only after the connection is done will the following
/// functions have an effect.
/// </remarks> <short> Call this function from the constructor of your StreamInterface implementation (or as soon as you get the MediaSource object).</short>
public void ConnectToSource(Phonon.MediaSource mediaSource)
{
interceptor.Invoke("connectToSource#", "connectToSource(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), mediaSource);
}
public static bool operator<(EffectParameter lhs, Phonon.EffectParameter rhs)
{
return((bool)staticInterceptor.Invoke("operator<#", "operator<(const Phonon::EffectParameter&) const", typeof(bool), typeof(EffectParameter), lhs, typeof(Phonon.EffectParameter), rhs));
}
public QsciDocument() : this((Type)null)
{
CreateProxy();
interceptor.Invoke("QsciDocument", "QsciDocument()", typeof(void));
}
public static bool ValidKey(int key)
{
return((bool)staticInterceptor.Invoke("validKey$", "validKey(int)", typeof(bool), typeof(int), key));
}
public void SetKey(int key)
{
interceptor.Invoke("setKey$", "setKey(int)", typeof(void), typeof(int), key);
}
// void setModelData(const QList<QExplicitlySharedDataPointer<Phonon::ObjectDescriptionData> >& arg1); >>>> NOT CONVERTED
// QList<QExplicitlySharedDataPointer<Phonon::ObjectDescriptionData> > modelData(); >>>> NOT CONVERTED
// QExplicitlySharedDataPointer<Phonon::ObjectDescriptionData> modelData(const QModelIndex& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Returns the number of rows in the model. This value corresponds
/// to the size of the list passed through setModelData.
/// \param parent The optional <pre>parent</pre> argument is used in most models to specify
/// the parent of the rows to be counted. Because this is a list if a
/// valid parent is specified the result will always be 0.
/// Reimplemented from QAbstractItemModel.
/// \see QAbstractItemModel.RowCount
/// </remarks> <short> Returns the number of rows in the model.</short>
public int RowCount(QModelIndex parent)
{
return((int)interceptor.Invoke("rowCount#", "rowCount(const QModelIndex&) const", typeof(int), typeof(QModelIndex), parent));
}
// Phonon::MediaNode* MediaNode(Phonon::MediaNodePrivate& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Tells whether the backend provides an implementation of this
/// class.
/// \return <code>true</code> if backend provides an implementation
/// \return <code>false</code> if the object is not implemented by the backend
/// </remarks> <short> Tells whether the backend provides an implementation of this class.</short>
public bool IsValid()
{
return((bool)interceptor.Invoke("isValid", "isValid() const", typeof(bool)));
}
/// <remarks>
/// Convenience function to create a MediaObject and AudioOutput connected by
/// a path.
/// </remarks> <short> Convenience function to create a MediaObject and AudioOutput connected by a path.</short>
public static Phonon.MediaObject CreatePlayer(Phonon.Category category, Phonon.MediaSource source)
{
return((Phonon.MediaObject)staticInterceptor.Invoke("createPlayer$#", "createPlayer(Phonon::Category, const Phonon::MediaSource&)", typeof(Phonon.MediaObject), typeof(Phonon.Category), category, typeof(Phonon.MediaSource), source));
}
/// <remarks>
/// Inverts an image. If the machine supports MMX this can do two pixels
/// at a time, otherwise it's the same as QImage.InvertPixels().
/// <param> name="img" The image to invert.
/// </param><param> name="mode" If to invert the alpha channel or not.
/// </param></remarks> <author> Daniel M. Duley (mosfet)
/// </author>
/// <short> Inverts an image.</short>
public static bool Invert(QImage img, QImage.InvertMode mode)
{
return((bool)staticInterceptor.Invoke("invert#$", "invert(QImage&, QImage::InvertMode)", typeof(bool), typeof(QImage), img, typeof(QImage.InvertMode), mode));
}
public static new string Tr(string s, string c)
{
return((string)staticInterceptor.Invoke("tr$$", "tr(const char*, const char*)", typeof(string), typeof(string), s, typeof(string), c));
}
public static bool operator==(ObjectDescriptionData lhs, Phonon.ObjectDescriptionData otherDescription)
{
return((bool)staticInterceptor.Invoke("operator==#", "operator==(const Phonon::ObjectDescriptionData&) const", typeof(bool), typeof(ObjectDescriptionData), lhs, typeof(Phonon.ObjectDescriptionData), otherDescription));
}
