public virtual int Offset(KTimeZone caller, int t)
{
return (int) interceptor.Invoke("offset#$", "offset(const KTimeZone*, time_t) const", typeof(int), typeof(KTimeZone), caller, typeof(int), t);
}
public virtual int OffsetAtUtc(KTimeZone caller, QDateTime utcDateTime)
{
return (int) interceptor.Invoke("offsetAtUtc##", "offsetAtUtc(const KTimeZone*, const QDateTime&) const", typeof(int), typeof(KTimeZone), caller, typeof(QDateTime), utcDateTime);
}
public virtual bool IsDst(KTimeZone caller, int t)
{
return (bool) interceptor.Invoke("isDst#$", "isDst(const KTimeZone*, time_t) const", typeof(bool), typeof(KTimeZone), caller, typeof(int), t);
}
public virtual bool IsDstAtUtc(KTimeZone caller, QDateTime utcDateTime)
{
return (bool) interceptor.Invoke("isDstAtUtc##", "isDstAtUtc(const KTimeZone*, const QDateTime&) const", typeof(bool), typeof(KTimeZone), caller, typeof(QDateTime), utcDateTime);
}
/// <remarks>
/// Removes a time zone from the collection.
/// <param> name="zone" time zone to remove
/// </param></remarks> <return> the time zone which was removed, or invalid if not found
/// </return>
/// <short> Removes a time zone from the collection.</short>
/// <see> clear</see>
/// <see> add</see>
public KTimeZone Remove(KTimeZone zone)
{
return (KTimeZone) interceptor.Invoke("remove#", "remove(const KTimeZone&)", typeof(KTimeZone), typeof(KTimeZone), zone);
}
/// <remarks>
/// Sets the time zone for the time specification.
/// To set the time zone to the current local system time zone,
/// setType(LocalZone) may optionally be used instead.
/// <param> name="tz" new time zone
/// </param></remarks> <short> Sets the time zone for the time specification.</short>
/// <see> timeZone</see>
/// <see> setType(SpecType)</see>
public void SetType(KTimeZone tz)
{
interceptor.Invoke("setType#", "setType(const KTimeZone&)", typeof(void), typeof(KTimeZone), tz);
}
public LeapSeconds(KTimeZone.LeapSeconds c)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("LeapSeconds#", "LeapSeconds(const KTimeZone::LeapSeconds&)", typeof(void), typeof(KTimeZone.LeapSeconds), c);
}
/// <remarks>
/// Format a time zone name in a standardised manner. The returned value is
/// transformed via an i18n lookup, so the caller should previously have
/// set the time zone catalog:
/// <pre>
/// KGlobal.Locale().InsertCatalog( "timezones4" );
/// </pre>
/// </remarks> <return> formatted time zone name.
/// </return>
/// <short> Format a time zone name in a standardised manner.</short>
public static string DisplayName(KTimeZone zone)
{
return (string) staticInterceptor.Invoke("displayName#", "displayName(const KTimeZone&)", typeof(string), typeof(KTimeZone), zone);
}
public List<QDateTime> TransitionTimes(KTimeZone.Phase phase)
{
return (List<QDateTime>) interceptor.Invoke("transitionTimes#", "transitionTimes(const KTimeZone::Phase&) const", typeof(List<QDateTime>), typeof(KTimeZone.Phase), phase);
}
/// <remarks>
/// Update the definition of the time zone to be identical to another
/// KTimeZone instance. A prerequisite is that the two instances must
/// have the same name.
/// The main purpose of this method is to allow updates of the time zone
/// definition by derived classes without invalidating pointers to the
/// instance (particularly pointers held by KDateTime objects). Note
/// that the KTimeZoneData object and KTimeZoneSource pointer are not
/// updated: the caller class should do this itself by calling setData().
/// <param> name="other" time zone whose definition is to be used
/// </param></remarks> <return> true if definition was updated (i.e. names are the same)
/// </return>
/// <short> Update the definition of the time zone to be identical to another KTimeZone instance.</short>
/// <see> setData</see>
public bool UpdateBase(KTimeZone other)
{
return (bool) interceptor.Invoke("updateBase#", "updateBase(const KTimeZone&)", typeof(bool), typeof(KTimeZone), other);
}
/// <remarks>
/// Return the times of all daylight saving transitions to a given time zone
/// phase, in time order. If desired, the times returned may be restricted to
/// a specified time range.
/// Note that some time zone data sources (such as system time zones accessed
/// via the system libraries) may not allow a list of daylight saving time
/// changes to be compiled easily. In such cases, this method will return an
/// empty list.
/// <param> name="phase" time zone phase
/// </param><param> name="start" start UTC date/time, or invalid date/time to return all transitions
/// up to <code>end.</code> <code>start.timeSpec</code>() must be Qt.UTC, else
/// <code>start</code> will be considered invalid.
/// </param><param> name="end" end UTC date/time, or invalid date/time for no end. <code>end.timeSpec</code>()
/// must be Qt.UTC, else <code>end</code> will be considered invalid.
/// </param></remarks> <return> ordered list of transition times
/// </return>
/// <short> Return the times of all daylight saving transitions to a given time zone phase, in time order.</short>
/// <see> hasTransitions</see>
/// <see> transition</see>
/// <see> transitions</see>
public List<QDateTime> TransitionTimes(KTimeZone.Phase phase, QDateTime start, QDateTime end)
{
return (List<QDateTime>) interceptor.Invoke("transitionTimes###", "transitionTimes(const KTimeZone::Phase&, const QDateTime&, const QDateTime&) const", typeof(List<QDateTime>), typeof(KTimeZone.Phase), phase, typeof(QDateTime), start, typeof(QDateTime), end);
}
/// <remarks>
/// Converts a date/time, which is interpreted as being local time in this
/// time zone, into local time in another time zone.
/// <param> name="newZone" other time zone which the time is to be converted into
/// </param><param> name="zoneDateTime" local date/time. An error occurs if
/// <code>zoneDateTime.timeSpec</code>() is not Qt.LocalTime.
/// </param></remarks> <return> converted date/time, or invalid date/time if error
/// </return>
/// <short> Converts a date/time, which is interpreted as being local time in this time zone, into local time in another time zone.</short>
/// <see> toUtc</see>
/// <see> toZoneTime</see>
public QDateTime Convert(KTimeZone newZone, QDateTime zoneDateTime)
{
return (QDateTime) interceptor.Invoke("convert##", "convert(const KTimeZone&, const QDateTime&) const", typeof(QDateTime), typeof(KTimeZone), newZone, typeof(QDateTime), zoneDateTime);
}
public Phase(KTimeZone.Phase rhs)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Phase#", "Phase(const KTimeZone::Phase&)", typeof(void), typeof(KTimeZone.Phase), rhs);
}
public virtual int OffsetAtZoneTime(KTimeZone caller, QDateTime zoneDateTime, ref int secondOffset)
{
StackItem[] stack = new StackItem[4];
#if DEBUG
stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(caller);
#else
stack[1].s_class = (IntPtr) GCHandle.Alloc(caller);
#endif
#if DEBUG
stack[2].s_class = (IntPtr) DebugGCHandle.Alloc(zoneDateTime);
#else
stack[2].s_class = (IntPtr) GCHandle.Alloc(zoneDateTime);
#endif
stack[3].s_int = secondOffset;
interceptor.Invoke("offsetAtZoneTime##$", "offsetAtZoneTime(const KTimeZone*, const QDateTime&, int*) const", stack);
#if DEBUG
DebugGCHandle.Free((GCHandle) stack[1].s_class);
#else
((GCHandle) stack[1].s_class).SynchronizedFree();
#endif
#if DEBUG
DebugGCHandle.Free((GCHandle) stack[2].s_class);
#else
((GCHandle) stack[2].s_class).SynchronizedFree();
#endif
secondOffset = stack[3].s_int;
return stack[0].s_int;
}
/// <remarks>
/// Returns the time converted to a specified time zone.
/// If the instance is a local clock time, it is first set to the local time
/// zone, and then converted to <code>zone.</code>
/// If the instance is a date-only value, a date-only value in <code>zone</code> is
/// returned, with the date unchanged.
/// <param> name="zone" time zone to convert to
/// </param></remarks> <return> converted time
/// </return>
/// <short> Returns the time converted to a specified time zone.</short>
/// <see> toUtc</see>
/// <see> toOffsetFromUtc</see>
/// <see> toLocalZone</see>
/// <see> toTimeSpec</see>
/// <see> KTimeZone.Convert</see>
public KDateTime ToZone(KTimeZone zone)
{
return (KDateTime) interceptor.Invoke("toZone#", "toZone(const KTimeZone&) const", typeof(KDateTime), typeof(KTimeZone), zone);
}
public override bool HasTransitions(KTimeZone caller)
{
return (bool) interceptor.Invoke("hasTransitions#", "hasTransitions(const KTimeZone*) const", typeof(bool), typeof(KTimeZone), caller);
}
/// <remarks>
/// Constructs a time specification for a given time zone.
/// If <code>tz</code> is KTimeZone.Utc(), the time specification type is set to <code>UTC.</code>
/// <param> name="tz" time zone
/// </param></remarks> <short> Constructs a time specification for a given time zone.</short>
public Spec(KTimeZone tz)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Spec#", "Spec(const KTimeZone&)", typeof(void), typeof(KTimeZone), tz);
}
public override KTimeZoneData Parse(KTimeZone zone)
{
return (KTimeZoneData) interceptor.Invoke("parse#", "parse(const KTimeZone&) const", typeof(KTimeZoneData), typeof(KTimeZone), zone);
}
/// <remarks>
/// Adds a time zone to the collection.
/// The time zone's name must be unique within the collection.
/// <param> name="zone" time zone to add
/// </param></remarks> <return> @c true if successful, @c false if zone's name duplicates one already in the collection
/// </return>
/// <short> Adds a time zone to the collection.</short>
/// <see> remove</see>
public bool Add(KTimeZone zone)
{
return (bool) interceptor.Invoke("add#", "add(const KTimeZone&)", typeof(bool), typeof(KTimeZone), zone);
}
