상속: Object, IDisposable
예제 #1
0
 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);
 }
예제 #2
0
 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);
 }
예제 #3
0
 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);
 }
예제 #4
0
 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);
 }
예제 #5
0
파일: KTimeZones.cs 프로젝트: KDE/kimono
 /// <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);
 }
예제 #6
0
 /// <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);
 }
예제 #7
0
 public LeapSeconds(KTimeZone.LeapSeconds c)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("LeapSeconds#", "LeapSeconds(const KTimeZone::LeapSeconds&)", typeof(void), typeof(KTimeZone.LeapSeconds), c);
 }
예제 #8
0
 /// <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);
 }
예제 #9
0
 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);
 }
예제 #10
0
 /// <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);
 }
예제 #11
0
 /// <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);
 }
예제 #12
0
 /// <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);
 }
예제 #13
0
 public Phase(KTimeZone.Phase rhs)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("Phase#", "Phase(const KTimeZone::Phase&)", typeof(void), typeof(KTimeZone.Phase), rhs);
 }
예제 #14
0
 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;
 }
예제 #15
0
 /// <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);
 }
예제 #16
0
 public override bool HasTransitions(KTimeZone caller)
 {
     return (bool) interceptor.Invoke("hasTransitions#", "hasTransitions(const KTimeZone*) const", typeof(bool), typeof(KTimeZone), caller);
 }
예제 #17
0
 /// <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);
 }
예제 #18
0
 public override KTimeZoneData Parse(KTimeZone zone)
 {
     return (KTimeZoneData) interceptor.Invoke("parse#", "parse(const KTimeZone&) const", typeof(KTimeZoneData), typeof(KTimeZone), zone);
 }
예제 #19
0
파일: KTimeZones.cs 프로젝트: KDE/kimono
 /// <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);
 }