Completed
Last Updated: 31 Jan 2024 11:39 by ADMIN
Release 2024 Q1 (2024.1.130)

If I set '2 Settimane' (2 Weeks in English)  and re-open the appointment it show '2 ore' (2 hours in English) or

If i set '4 giorni' (4 days in English)  and re-open the appointment it show '4 ore' (4 hours in English)

The code snippet reproduces the issue:

Public Class RadForm1
    Sub New()

        RadSchedulerLocalizationProvider.CurrentProvider = New ItalianSchedulerLocalizationProvider()
        InitializeComponent()

      

    End Sub
    Private Sub RadForm1_Initialized(sender As Object, e As EventArgs) Handles Me.Initialized
        ' 
    End Sub
End Class
Public Class ItalianSchedulerLocalizationProvider
    Inherits RadSchedulerLocalizationProvider

    Public Overrides Function GetLocalizedString(id As String) As String
        Select Case id
            Case RadSchedulerStringId.NextAppointment
                Return "Prossimi Appuntamenti"
            Case RadSchedulerStringId.PreviousAppointment
                Return "Appuntamenti Precedenti"
            Case RadSchedulerStringId.AppointmentDialogTitle
                Return "Modifica Appuntamento"
            Case RadSchedulerStringId.AppointmentDialogSubject
                Return "Oggetto:"
            Case RadSchedulerStringId.AppointmentDialogLocation
                Return "Posizione:"
            Case RadSchedulerStringId.AppointmentDialogBackground
                Return "Sfondo:"
            Case RadSchedulerStringId.AppointmentDialogDescription
                Return "Descrizione:"
            Case RadSchedulerStringId.AppointmentDialogStartTime
                Return "Ora di inizio:"
            Case RadSchedulerStringId.AppointmentDialogEndTime
                Return "Ora di fine:"
            Case RadSchedulerStringId.AppointmentDialogAllDay
                Return "Tutto il giorno"
            Case RadSchedulerStringId.AppointmentDialogResource
                Return "Risorsa:"
            Case RadSchedulerStringId.AppointmentDialogStatus
                Return "Mostra come:"
            Case RadSchedulerStringId.AppointmentDialogOK
                Return "OK"
            Case RadSchedulerStringId.AppointmentDialogCancel
                Return "Annulla"
            Case RadSchedulerStringId.AppointmentDialogDelete
                Return "Elimina"
            Case RadSchedulerStringId.AppointmentDialogRecurrence
                Return "Ricorrenza"
            Case RadSchedulerStringId.OpenRecurringDialogTitle
                Return "Apri elemento ricorrente"
            Case RadSchedulerStringId.DeleteRecurrenceDialogOK
                Return "OK"
            Case RadSchedulerStringId.OpenRecurringDialogOK
                Return "OK"
            Case RadSchedulerStringId.DeleteRecurrenceDialogCancel
                Return "Annulla"
            Case RadSchedulerStringId.OpenRecurringDialogCancel
                Return "Annulla"
            Case RadSchedulerStringId.OpenRecurringDialogLabel
                Return """{0}"" è un appuntamento" & vbLf & "ricorrente. Vuoi aprire" & vbLf & "la sola occorenza o la serie?"
            Case RadSchedulerStringId.OpenRecurringDialogRadioOccurrence
                Return "Apri questa occorrenza."
            Case RadSchedulerStringId.OpenRecurringDialogRadioSeries
                Return "Apri la serie."
            Case RadSchedulerStringId.DeleteRecurrenceDialogTitle
                Return "Conferma cancellazione"
            Case RadSchedulerStringId.DeleteRecurrenceDialogRadioOccurrence
                Return "Elimina questa occorrenza."
            Case RadSchedulerStringId.DeleteRecurrenceDialogRadioSeries
                Return "Elimina la serie."
            Case RadSchedulerStringId.DeleteRecurrenceDialogLabel
                Return "Vuoi eliminare tutte le occorrenze dell'appuntamento ricorrente ""{0}"", o sola questa?"
            Case RadSchedulerStringId.RecurrenceDragDropCreateExceptionDialogText
                Return "Hai modificato la data di una singola occorrenza di un appuntamento ricorrente. Per modificare tutte le date, aprire la serie." & vbLf & "Vuoi cambiare solo questa?"
            Case RadSchedulerStringId.RecurrenceDragDropValidationSameDateText
                Return "Due occorrenze della stessa serie non possono verificarsi nello stesso giorno."
            Case RadSchedulerStringId.RecurrenceDragDropValidationSkipOccurrenceText
                Return "Non è possibile riprogrammare un'occorrenza di un appuntamento ricorrente se viene saltata un'occorrenza successiva dello stesso appuntamento."
            Case RadSchedulerStringId.RecurrenceDialogMessageBoxText
                Return "La data di inizio deve essere precedente alla data di fine."
            Case RadSchedulerStringId.RecurrenceDialogMessageBoxWrongRecurrenceRuleText
                Return "Il modello di ricorrenza non è valido."
            Case RadSchedulerStringId.RecurrenceDialogMessageBoxTitle
                Return "Errore di validazione"
            Case RadSchedulerStringId.RecurrenceDialogTitle
                Return "Modifica ricorrenza"
            Case RadSchedulerStringId.RecurrenceDialogAppointmentTimeGroup
                Return "Orario dell'appuntamento"
            Case RadSchedulerStringId.RecurrenceDialogDuration
                Return "Durata:"
            Case RadSchedulerStringId.RecurrenceDialogAppointmentEnd
                Return "Fine:"
            Case RadSchedulerStringId.RecurrenceDialogAppointmentStart
                Return "Inizio:"
            Case RadSchedulerStringId.RecurrenceDialogRecurrenceGroup
                Return "Modello di ricorrenza"
            Case RadSchedulerStringId.RecurrenceDialogRangeGroup
                Return "Intervallo di ricorrenza"
            Case RadSchedulerStringId.RecurrenceDialogOccurrences
                Return "occorrenze"
            Case RadSchedulerStringId.RecurrenceDialogRecurrenceStart
                Return "Inizio:"
            Case RadSchedulerStringId.RecurrenceDialogYearly
                Return "Annuale"
            Case RadSchedulerStringId.RecurrenceDialogHourly
                Return "Ora"
            Case RadSchedulerStringId.RecurrenceDialogMonthly
                Return "Mese"
            Case RadSchedulerStringId.RecurrenceDialogWeekly
                Return "Settimana"
            Case RadSchedulerStringId.RecurrenceDialogDaily
                Return "Giorno"
            Case RadSchedulerStringId.RecurrenceDialogEndBy
                Return "Fine entro:"
            Case RadSchedulerStringId.RecurrenceDialogEndAfter
                Return "Fine dopo:"
            Case RadSchedulerStringId.RecurrenceDialogNoEndDate
                Return "Nessuna data di fine"
            Case RadSchedulerStringId.RecurrenceDialogAllDay
                Return "Evento tutto il giorno"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown1Day
                Return "1 giorno"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown2Days
                Return "2 giorni"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown3Days
                Return "3 giorni"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown4Days
                Return "4 giorni"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown1Week
                Return "1 settimana"
            Case RadSchedulerStringId.RecurrenceDialogDurationDropDown2Weeks
                Return "2 settimane"
            Case RadSchedulerStringId.RecurrenceDialogOK
                Return "OK"
            Case RadSchedulerStringId.RecurrenceDialogCancel
                Return "Annulla"
            Case RadSchedulerStringId.RecurrenceDialogRemoveRecurrence
                Return "Elimina Ricorrenza"
            Case RadSchedulerStringId.HourlyRecurrenceEvery
                Return "Ogni"
            Case RadSchedulerStringId.HourlyRecurrenceHours
                Return "Ora(e)"
            Case RadSchedulerStringId.DailyRecurrenceEveryDay
                Return "Ogni"
            Case RadSchedulerStringId.DailyRecurrenceEveryWeekday
                Return "Ogni giorno della settimana"
            Case RadSchedulerStringId.DailyRecurrenceDays
                Return "giorno(i)"
            Case RadSchedulerStringId.WeeklyRecurrenceRecurEvery
                Return "Ricorre ogni"
            Case RadSchedulerStringId.WeeklyRecurrenceWeeksOn
                Return "settimana(e) dopo:"
            Case RadSchedulerStringId.WeeklyRecurrenceSunday
                Return "Domenica"
            Case RadSchedulerStringId.WeeklyRecurrenceMonday
                Return "Lunedì"
            Case RadSchedulerStringId.WeeklyRecurrenceTuesday
                Return "Martedì"
            Case RadSchedulerStringId.WeeklyRecurrenceWednesday
                Return "Mercoledì"
            Case RadSchedulerStringId.WeeklyRecurrenceThursday
                Return "Giovedì"
            Case RadSchedulerStringId.WeeklyRecurrenceFriday
                Return "Venerdì"
            Case RadSchedulerStringId.WeeklyRecurrenceSaturday
                Return "Sabato"
            Case RadSchedulerStringId.WeeklyRecurrenceDay
                Return "Giorno"
            Case RadSchedulerStringId.WeeklyRecurrenceWeekday
                Return "Giorno lavorativo"
            Case RadSchedulerStringId.WeeklyRecurrenceWeekendDay
                Return "Giorno del fine settimana"
            Case RadSchedulerStringId.MonthlyRecurrenceDay
                Return "Giorno"
            Case RadSchedulerStringId.MonthlyRecurrenceWeek
                Return "Il"
            Case RadSchedulerStringId.MonthlyRecurrenceDayOfMonth
                Return "di ogni"
            Case RadSchedulerStringId.MonthlyRecurrenceMonths
                Return "mese(i)"
            Case RadSchedulerStringId.MonthlyRecurrenceWeekOfMonth
                Return "di ogni"
            Case RadSchedulerStringId.MonthlyRecurrenceFirst
                Return "Primo"
            Case RadSchedulerStringId.MonthlyRecurrenceSecond
                Return "Secondo"
            Case RadSchedulerStringId.MonthlyRecurrenceThird
                Return "Terzo"
            Case RadSchedulerStringId.MonthlyRecurrenceFourth
                Return "Quarto"
            Case RadSchedulerStringId.MonthlyRecurrenceLast
                Return "Ultimo"
            Case RadSchedulerStringId.YearlyRecurrenceDayOfMonth
                Return "Ogni"
            Case RadSchedulerStringId.YearlyRecurrenceWeekOfMonth
                Return "Il"
            Case RadSchedulerStringId.YearlyRecurrenceOfMonth
                Return "di"
            Case RadSchedulerStringId.YearlyRecurrenceJanuary
                Return "Gennaio"
            Case RadSchedulerStringId.YearlyRecurrenceFebruary
                Return "Febbraio"
            Case RadSchedulerStringId.YearlyRecurrenceMarch
                Return "Marzo"
            Case RadSchedulerStringId.YearlyRecurrenceApril
                Return "Aprile"
            Case RadSchedulerStringId.YearlyRecurrenceMay
                Return "Maggio"
            Case RadSchedulerStringId.YearlyRecurrenceJune
                Return "Giugno"
            Case RadSchedulerStringId.YearlyRecurrenceJuly
                Return "Luglio"
            Case RadSchedulerStringId.YearlyRecurrenceAugust
                Return "Agosto"
            Case RadSchedulerStringId.YearlyRecurrenceSeptember
                Return "Settembre"
            Case RadSchedulerStringId.YearlyRecurrenceOctober
                Return "Ottobre"
            Case RadSchedulerStringId.YearlyRecurrenceNovember
                Return "Novembre"
            Case RadSchedulerStringId.YearlyRecurrenceDecember
                Return "Dicembre"
            Case RadSchedulerStringId.BackgroundNone
                Return "Nessuna"
            Case RadSchedulerStringId.BackgroundImportant
                Return "Importante"
            Case RadSchedulerStringId.BackgroundBusiness
                Return "Business"
            Case RadSchedulerStringId.BackgroundPersonal
                Return "Personale"
            Case RadSchedulerStringId.BackgroundVacation
                Return "Vacanza"
            Case RadSchedulerStringId.BackgroundMustAttend
                Return "Deve Frequentare"
            Case RadSchedulerStringId.BackgroundTravelRequired
                Return "Viaggio Richiesto"
            Case RadSchedulerStringId.BackgroundNeedsPreparation
                Return "Necessita di preparazione"
            Case RadSchedulerStringId.BackgroundBirthday
                Return "Compleanno"
            Case RadSchedulerStringId.BackgroundAnniversary
                Return "Anniversario"
            Case RadSchedulerStringId.BackgroundPhoneCall
                Return "Chiamata Tel."
            Case RadSchedulerStringId.StatusBusy
                Return "Occupato"
            Case RadSchedulerStringId.StatusFree
                Return "Libero"
            Case RadSchedulerStringId.StatusTentative
                Return "Tentative"
            Case RadSchedulerStringId.StatusUnavailable
                Return "Non Disponibile"
            Case RadSchedulerStringId.ReminderNone
                Return "Nessuno"
            Case RadSchedulerStringId.ReminderOneMinute
                Return "1 minuto"
            Case RadSchedulerStringId.ReminderMinutes
                Return " minuti"
            Case RadSchedulerStringId.ReminderOneSecond
                Return "1 secondo"
            Case RadSchedulerStringId.ReminderSeconds
                Return " secondi"
            Case RadSchedulerStringId.ReminderDays
                Return " giorni"
            Case RadSchedulerStringId.ReminderWeeks
                Return " settimane"
            Case RadSchedulerStringId.ReminderHours
                Return " ore"
            Case RadSchedulerStringId.ReminderZeroMinutes
                Return "0 minuti"
            Case RadSchedulerStringId.ReminderFiveMinutes
                Return "5 minuti"
            Case RadSchedulerStringId.ReminderTenMinutes
                Return "10 minuti"
            Case RadSchedulerStringId.ReminderFifteenMinutes
                Return "15 minuti"
            Case RadSchedulerStringId.ReminderThirtyMinutes
                Return "30 minuti"
            Case RadSchedulerStringId.ReminderOneHour
                Return "1 ora"
            Case RadSchedulerStringId.ReminderTwoHours
                Return "2 ore"
            Case RadSchedulerStringId.ReminderThreeHours
                Return "3 ore"
            Case RadSchedulerStringId.ReminderFourHours
                Return "4 ore"
            Case RadSchedulerStringId.ReminderFiveHours
                Return "5 ore"
            Case RadSchedulerStringId.ReminderSixHours
                Return "6 ore"
            Case RadSchedulerStringId.ReminderSevenHours
                Return "7 ore"
            Case RadSchedulerStringId.ReminderEightHours
                Return "8 ore"
            Case RadSchedulerStringId.ReminderNineHours
                Return "9 ore"
            Case RadSchedulerStringId.ReminderTenHours
                Return "10 ore"
            Case RadSchedulerStringId.ReminderElevenHours
                Return "11 ore"
            Case RadSchedulerStringId.ReminderTwelveHours
                Return "12 ore"
            Case RadSchedulerStringId.ReminderEighteenHours
                Return "18 ore"
            Case RadSchedulerStringId.ReminderOneDay
                Return "1 giorno"
            Case RadSchedulerStringId.ReminderTwoDays
                Return "2 giorni"
            Case RadSchedulerStringId.ReminderThreeDays
                Return "3 giorni"
            Case RadSchedulerStringId.ReminderFourDays
                Return "4 giorni"
            Case RadSchedulerStringId.ReminderOneWeek
                Return "1 settimana"
            Case RadSchedulerStringId.ReminderTwoWeeks
                Return "2 settimane"
            Case RadSchedulerStringId.Reminder
                Return "Promemoria"
            Case RadSchedulerStringId.ContextMenuNewAppointment
                Return "Nuovo Appuntamento"
            Case RadSchedulerStringId.ContextMenuEditAppointment
                Return "Modifica Appuntamento"
            Case RadSchedulerStringId.ContextMenuNewRecurringAppointment
                Return "Nuovo appuntamento ricorrente"
            Case RadSchedulerStringId.ContextMenu60Minutes
                Return "60 Minuti"
            Case RadSchedulerStringId.ContextMenu30Minutes
                Return "30 Minuti"
            Case RadSchedulerStringId.ContextMenu15Minutes
                Return "15 Minuti"
            Case RadSchedulerStringId.ContextMenu10Minutes
                Return "10 Minuti"
            Case RadSchedulerStringId.ContextMenu6Minutes
                Return "6 Minuti"
            Case RadSchedulerStringId.ContextMenu5Minutes
                Return "5 Minuti"
            Case RadSchedulerStringId.ContextMenuNavigateToNextView
                Return "Vista Successiva"
            Case RadSchedulerStringId.ContextMenuNavigateToPreviousView
                Return "Vista Precedente"
            Case RadSchedulerStringId.ContextMenuTimescales
                Return "Scale temporali"
            Case RadSchedulerStringId.ContextMenuTimescalesYear
                Return "Anno"
            Case RadSchedulerStringId.ContextMenuTimescalesMonth
                Return "Mese"
            Case RadSchedulerStringId.ContextMenuTimescalesWeek
                Return "Settimana"
            Case RadSchedulerStringId.ContextMenuTimescalesDay
                Return "Giorno"
            Case RadSchedulerStringId.ContextMenuTimescalesHour
                Return "Ora"
            Case RadSchedulerStringId.ContextMenuTimescalesHalfHour
                Return "30 minuti"
            Case RadSchedulerStringId.ContextMenuTimescalesFifteenMinutes
                Return "15 minuti"
            Case RadSchedulerStringId.ErrorProviderWrongAppointmentDates
                Return "L'ora di fine dell'appuntamento è inferiore o uguale all'ora di inizio!"
            Case RadSchedulerStringId.ErrorProviderWrongExceptionDuration
                Return "L'intervallo di ricorrenza deve essere maggiore o uguale alla durata dell'appuntamento!"
            Case RadSchedulerStringId.ErrorProviderExceptionSameDate
                Return "Due occorrenze della stessa serie non possono verificarsi nello stesso giorno."
            Case RadSchedulerStringId.ErrorProviderExceptionSkipOverDate
                Return "L'eccezione di ricorrenza non può ignorare un'occorrenza successiva dello stesso appuntamento."
            Case RadSchedulerStringId.TimeZoneLocal
                Return "Locale"
            Case RadSchedulerStringId.CategoryNone
                Return "Personale"
            Case RadSchedulerStringId.CategoryBlue
                Return "Riunione"
            Case RadSchedulerStringId.CategoryGray
                Return "Contabilita"
            Case RadSchedulerStringId.CategoryGreen
                Return "SiCoGe Impegno"
            Case RadSchedulerStringId.CategoryLavender
                Return "SiCoGe OP"
            Case RadSchedulerStringId.CategoryOlive
                Return "SiCoGe OA"
            Case RadSchedulerStringId.CategoryOrange
                Return "SiCoGe Var. Competenza"
            Case RadSchedulerStringId.CategoryOrange
                Return "SiCoGe Var. Cassa"

            Case Else
                Debug.Print(id)
                Return "*UNKNOWN"
        End Select
    End Function

 

Completed
Last Updated: 07 Jun 2023 10:38 by ADMIN
Release R2 2023 (2023.2.606)

I have tested in brand new projects (.NET 6 and .NET Framework) and the default functionality of the drag drop services in RadScheduler and RadGridView. Indeed, the cursor is missing in .NET 6. The following screenshots illustrate the difference.

.NET 6:

 

Completed
Last Updated: 07 Jun 2023 10:38 by ADMIN
Release R2 2023 (2023.2.606)

Steps that lead to the undesired behavior:

1. Create a VB project with one of the templates:

2. Initially, there is no subscription to the CalendarUserControl.Load event:

3. After opening the designer, you are subscribing to the Load event by double-clicking the Load event in the Properties section:

Then, the generated event handler is underlined as in the above screenshot.

 

Completed
Last Updated: 27 Mar 2023 06:39 by ADMIN
Release R1 2023 SP1

Use the following code: 

    Public Sub New()
        InitializeComponent()

        RadSchedulerReminder1.TimeInterval = 500

        Dim appointment As New Appointment(DateTime.Now.AddDays(-1), TimeSpan.FromHours(1), "A")
        appointment.Reminder = New TimeSpan(10000)
        Me.RadScheduler1.Appointments.Add(appointment)

        Dim appointment2 As New Appointment(DateTime.Now.AddHours(-2), TimeSpan.FromHours(1), "B")
        appointment2.Reminder = New TimeSpan(10000)
        Me.RadScheduler1.Appointments.Add(appointment2)

        RadSchedulerReminder1.StartReminderInterval = Date.Now.AddDays(-1)
        RadSchedulerReminder1.EndReminderInterval = Date.Now.AddDays(1)

    End Sub

    Private Sub RadForm1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        RadSchedulerReminder1.StartReminder()

        RadScheduler1.ActiveViewType = SchedulerViewType.Week

    End Sub

Drag "A" on the same interval as "B". You will notice that the reminder dialog will continue to show only "B".

Completed
Last Updated: 23 Sep 2022 13:07 by ADMIN
Release R3 2022
Created by: Maciej
Comments: 0
Category: Scheduler/Reminder
Type: Bug Report
6

The local time is EEST — Eastern European Summer Time (Current Offset: UTC/GMT +3 hours). Add an additional time zone IST — India Standard Time (Current Offset: UTC/GMT +5:30 hours). It is expected to show 2 hours and 30 minutes difference between the two times zones. However, it is 1 hour and 30 minutes:

    Public Sub New()
        InitializeComponent()

        allTimeZones = SchedulerTimeZone.GetSchedulerTimeZones()
        Dim mumbai As SchedulerTimeZone = GetSpecificTimeZone("India Standard Time")
        If Not mumbai.Equals(Me.RadScheduler1.GetDayView().DefaultTimeZone) Then
            RadScheduler1.GetDayView().TimeZones.Insert(0, mumbai)
        End If

        Dim utc As SchedulerTimeZone = GetSpecificTimeZone("UTC")
        If Not utc.Equals(Me.RadScheduler1.GetDayView().DefaultTimeZone) Then
            RadScheduler1.GetDayView().TimeZones.Insert(0, utc)
        End If
    End Sub
    Private Function GetSpecificTimeZone(_TimeZoneInformationID As String) As SchedulerTimeZone
        Try
            Dim tempZone As New SchedulerTimeZone((From t In allTimeZones.Where(Function(x) x.TimeZoneInformation.Id Like _TimeZoneInformationID) Select t.TimeZoneInformation).First)
            tempZone.Label = tempZone.TimeZoneInformation.BaseUtcOffset.ToString()
            Return tempZone
        Catch ex As Exception
            Return Nothing
        End Try
    End Function

Actual: 1 hour behind the expected

Expected:

Workaround:

Public Class Form1

    Private allTimeZones As List(Of SchedulerTimeZone)

    Public Sub New()
        InitializeComponent()

        Me.RadScheduler1.ElementProvider = New CustomSchedulerElementProvider(Me.RadScheduler1)


        allTimeZones = SchedulerTimeZone.GetSchedulerTimeZones()
        Dim mumbai As SchedulerTimeZone = GetSpecificTimeZone("India Standard Time")
        If Not mumbai.Equals(Me.RadScheduler1.GetDayView().DefaultTimeZone) Then
            RadScheduler1.GetDayView().TimeZones.Insert(0, mumbai)
        End If

        Dim utc As SchedulerTimeZone = GetSpecificTimeZone("UTC")
        If Not utc.Equals(Me.RadScheduler1.GetDayView().DefaultTimeZone) Then
            RadScheduler1.GetDayView().TimeZones.Insert(0, utc)
        End If
    End Sub
    Private Function GetSpecificTimeZone(_TimeZoneInformationID As String) As SchedulerTimeZone
        Try
            Dim tempZone As New SchedulerTimeZone((From t In allTimeZones.Where(Function(x) x.TimeZoneInformation.Id Like _TimeZoneInformationID) Select t.TimeZoneInformation).First)
            tempZone.Label = tempZone.TimeZoneInformation.BaseUtcOffset.ToString()
            Return tempZone
        Catch ex As Exception
            Return Nothing
        End Try
    End Function
End Class

Public Class CustomSchedulerElementProvider
        Inherits SchedulerElementProvider

        Public Sub New(scheduler As RadScheduler)
            MyBase.New(scheduler)
        End Sub

        Public Overrides Function CreateRulerPrimitive(area As DayViewAppointmentsArea, timeZone As SchedulerTimeZone) As RulerPrimitive
            Dim ruler As RulerPrimitive = MyBase.CreateRulerPrimitive(area, timeZone)
            ruler.RulerRenderer = New CustomRulerRenderer(ruler)
            Return ruler
        End Function
    End Class

Public Class CustomRulerRenderer
    Inherits RulerRenderer


    Public Sub New(ruler As RulerPrimitive)
        MyBase.New(ruler)
    End Sub

    Public Overrides Sub RenderHour(g As IGraphics, hour As Integer, bounds As RectangleF)
        hour += Me.ruler.StartScale + CInt(Math.Ceiling(Me.ruler.DefaultOffset))
        Dim currentTime As DateTime = DateTime.Now.Date.AddHours(hour)
        Dim percent As Single = Me.ruler.DefaultOffset - CSng(Math.Floor(CDbl(Me.ruler.DefaultOffset)))
        Dim x As Integer = Me.ruler.HourLineStartPosition
        Dim y As Single = CSng(Math.Ceiling(bounds.Top + (GetSpecificRange() * bounds.Height) * percent))
        Dim hourText As String = ""

        If Me.ruler.FormatStrings.HoursFormatString IsNot Nothing Then
            hourText = currentTime.ToString(Me.ruler.FormatStrings.HoursFormatString)
        End If

        'Dim args As RulerTextFormattingEventArgs = New RulerTextFormattingEventArgs(hourText, RulerTextFormattingContext.Hour, currentTime)
        'Me.ruler.Scheduler.OnRulerTextFormatting(args)
        'hourText = args.Text
        Dim minutesText As String = ""

        If Me.ruler.FormatStrings.MinutesFormatString IsNot Nothing Then
            minutesText = currentTime.ToString(Me.ruler.FormatStrings.MinutesFormatString)
        End If

        'args = New RulerTextFormattingEventArgs(minutesText, RulerTextFormattingContext.Minute, currentTime)
        'Me.ruler.scheduler.OnRulerTextFormatting(args)
        'minutesText = args.Text
        Dim measuredSize As Size = TextRenderer.MeasureText(hourText, Me.ruler.Font)
        measuredSize = DrawTimeText(g, y, hourText, minutesText, measuredSize)

        If ruler.RightToLeft Then
            g.DrawLine(Me.ruler.HourLineColor, Me.ruler.Bounds.Left, y, Me.ruler.Bounds.Width - x, y, Me.ruler.DpiScaleFactor.Height)
            g.DrawLine(Me.ruler.HourLineShadowColor, Me.ruler.Bounds.Left, y + Me.ruler.DpiScaleFactor.Height, Me.ruler.Bounds.Width - x, y + Me.ruler.DpiScaleFactor.Height, Me.ruler.DpiScaleFactor.Height)
        Else
            g.DrawLine(Me.ruler.HourLineColor, x, y, Me.ruler.Bounds.Width, y, Me.ruler.DpiScaleFactor.Height)
            g.DrawLine(Me.ruler.HourLineShadowColor, x, y + Me.ruler.DpiScaleFactor.Height, Me.ruler.Bounds.Width, y + Me.ruler.DpiScaleFactor.Height, Me.ruler.DpiScaleFactor.Height)
        End If
    End Sub

    Friend Function GetSpecificRange() As Integer
        Return 60 / CInt(Me.ruler.RangeFactor)
    End Function
End Class

Completed
Last Updated: 23 Sep 2022 13:07 by ADMIN
Release R3 2022

Please use the Demo application >> Scheduler example and follow the steps in the attached gif file.

Expected result: the deleted appointment should disappear from the grid after closing the edit dialog.

Actual result: the deleted appointment is still visible in the agenda grid after closing the edit dialog.

Note: pressing the Delete key when an appointment is selected in agenda view doesn't perform any delete operation. In the rest of the scheduler view, the selected appointment is deleted.

Workaround: after an appointment is deleted, refresh the agenda grid by changing the view:

    Private Sub RadScheduler1_AppointmentDeleted(sender As Object, e As SchedulerAppointmentEventArgs)
        Me.RadScheduler1.ActiveViewType = SchedulerViewType.Day
        Me.RadScheduler1.ActiveViewType = SchedulerViewType.Agenda
    End Sub

Completed
Last Updated: 23 Sep 2022 13:07 by ADMIN
Release R3 2022

Additional borders appear in AgendaView when the Date column is sorted. This behavior is observed in the following themes:

  • VisualStudio2012Light
  • Office2019Light
  • Office2019Gray
  • Office2019Dark
  • Office2013Dark (missing border)
  • Office2013Light (missing border)
  • TelerikMetro (missing border)
  • TelerikMetroBlue (missing border)
  • TelerikMetroTouch (missing border)
  • Office2010Black (missing border)
  • Office2010Silver (missing border)
  • Office2010Blue (missing border)
  • ControlDefault (missing border)
  • Breeze (missing border)
  • HighContrastBlack (missing border)
  • Office2007 (missing border)

 

Completed
Last Updated: 17 Aug 2021 11:21 by ADMIN
Release R3 2021
Completed
Last Updated: 27 Jul 2021 13:01 by ADMIN
Release R3 2021

Hi Guys,

             the colour scheme on your SchedulerBinderDataSource Appointment Mapping form is barely visible

Could you please darken the text so I can map things without squinting.

Thanks.

Completed
Last Updated: 20 Jul 2021 07:50 by ADMIN
Release R3 2021

1) create new project with a radScheduler

2) add a new appointment with a subject of: <>

3) program will crash with System.InvalidOperationException: 'Collection was modified after the enumerator was instantiated.'

 

The program will crash even if you have additional text before the "<>" but having text after it will allow the program to continue running however, none of the text after the "<>" will display.

Completed
Last Updated: 07 Jun 2021 15:04 by ADMIN
Release R2 2021 SP1

Hello,

I found an issue when retrieving appointments using MultiDayView.GetAppointmentsInInterval

The issue occurs when creating a new appointment where AllDay is set to true
In the appointment, the Start and End date is automatically both set to the same value
When adding the appointment to the MultidayView and retrieving the appointments in interval (interval is set to 1 minute) the Appointment is not returned.
I guess the call only uses the Start and End date and not using the AllDay value

 

Grtz Patrick

Completed
Last Updated: 30 Oct 2020 17:05 by ADMIN
Release R1 2021 (LIB 2020.3.1102)

Here is the code snippet:

    Sub New()

        InitializeComponent()

        Dim culture As CultureInfo = New CultureInfo("en-US")
        culture.DateTimeFormat.FirstDayOfWeek = DayOfWeek.Monday
        culture.DateTimeFormat.CalendarWeekRule = CalendarWeekRule.FirstFourDayWeek
        Me.RadScheduler1.Culture = culture

        Me.RadScheduler1.ActiveViewType = Telerik.WinControls.UI.SchedulerViewType.Timeline
        Dim timelineView As SchedulerTimelineView = Me.RadScheduler1.GetTimelineView()
        Dim scale As Timescales = Timescales.Weeks
        timelineView.ShowTimescale(scale) 

    End Sub
 

    Private Sub RadForm1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Dim baseDate As DateTime = DateTime.Today
        Dim start As DateTime() = New DateTime() {baseDate.AddHours(14.0), baseDate.AddDays(1.0).AddHours(9.0), baseDate.AddDays(2.0).AddHours(13.0)}
        Dim [end] As DateTime() = New DateTime() {baseDate.AddHours(16.0), baseDate.AddDays(1.0).AddHours(15.0), baseDate.AddDays(2.0).AddHours(17.0)}



        Dim appointment As Appointment = Nothing
        For i As Integer = 0 To 2
            appointment = New Appointment(start(i), [end](i), "A" & i, "D" & i, "L" & i) 
            Me.RadScheduler1.Appointments.Add(appointment)
        Next

        Me.RadScheduler1.ActiveView.StartDate = New DateTime(2020, 10, 11)
    End Sub

You will notice that if the StartDate is changed the appointments occupy the wrong cells until you scroll horizontally and the view is updated.

Completed
Last Updated: 15 Jun 2020 12:06 by ADMIN
Release R2 2020 SP1
Please refer to the attached gif files and the two projects. The project which uses Entity Framework doesn't generate a new record for the exceptional event. Without EF, it works OK.
Completed
Last Updated: 27 Apr 2020 07:37 by ADMIN
Release R2 2020
Created by: Ben
Comments: 1
Category: Scheduler/Reminder
Type: Feature Request
2

Hi,

I am using the CalHelper (as suggested by this) in order to convert RecurrenceRule back and forth to string in order to persist on the database.

With the minutely recurrence rule, it seems like the conversion is not done correctly.

Please check the below code:


            var recurrenceRule = new MinutelyRecurrenceRule();
            recurrenceRule.Start = new DateTime(2020, 4, 1);
            recurrenceRule.Interval = 30;
            recurrenceRule.End = new DateTime(2020, 4, 1, 2, 0, 0);
            var qString = CalHelper.RecurrenceRuleToString(recurrenceRule);
            RecurrenceRule recurrenceRule1;
            CalHelper.TryParseRecurrenceRule(qString, out recurrenceRule1);// recurrenceRule1 will be null

 

Is there a way to fix this issue?

Thanks,

Completed
Last Updated: 06 Dec 2019 14:27 by ADMIN
Release R1 2020 (LIB 2019.3.1209)
Created by: Bert
Comments: 5
Category: Scheduler/Reminder
Type: Bug Report
0

Please run the attached sample project and follow the steps illustrated in the gif file. Not always the selected appointment is dragged.

Workaround:

        public class CustomSchedulerInputBheavior : SchedulerInputBehavior
        {
            public CustomSchedulerInputBheavior(RadScheduler scheduler) : base(scheduler)
            {
            }

            Point mouseDownPosition = Point.Empty;
            public override bool HandleMouseDown(MouseEventArgs args)
            {
                mouseDownPosition = args.Location;
                return base.HandleMouseDown(args);
            }
            public override bool HandleMouseMove(MouseEventArgs args)
            {
                SchedulerCellElement cell = this.Scheduler.ElementTree.GetElementAtPoint(args.Location) as SchedulerCellElement;

                AppointmentElement appointment = this.Scheduler.ElementTree.GetElementAtPoint(args.Location) as AppointmentElement;
                if (appointment == null)
                {
                    appointment = this.Scheduler.ElementTree.GetElementAtPoint(this.mouseDownPosition) as AppointmentElement;
                }

                if (this.Scheduler.Behavior.ItemCapture != null && (this.Scheduler.Behavior.ItemCapture.Parent is RadScrollBarElement ||
                    this.Scheduler.Behavior.ItemCapture is RadScrollBarElement))
                {
                    return false;
                }

                if (this.Scheduler.Capture && args.Button == MouseButtons.Left)
                {
                     appointment = this.Scheduler.ElementTree.GetElementAtPoint(this.mouseDownPosition) as AppointmentElement;

                    FieldInfo fi = typeof(SchedulerInputBehavior).GetField("selecting", BindingFlags.Instance| BindingFlags.NonPublic);
                    bool selecting = (bool)fi.GetValue(this);
                    if (selecting)
                    {
                        if (cell != null && cell.AllowSelection && args.Button == MouseButtons.Left)
                        {
                            this.SelectCell(cell, true);
                        }
                    }
                    else if (this.Scheduler.SchedulerElement.ResizeBehavior.IsResizing)
                    {
                        this.Scheduler.SchedulerElement.ResizeBehavior.Resize(args.Location);
                    }
                    else if (appointment != null && IsRealDrag(args.Location))
                    {
                        this.Scheduler.Capture = false;
                        this.Scheduler.DragDropBehavior.BeginDrag((SchedulerVisualElement)appointment.Parent, appointment);
                        return true;
                    }
                }
                else
                {
                    if (appointment != null)
                    {
                        this.Scheduler.SchedulerElement.ResizeBehavior.RequestResize(appointment, (SchedulerVisualElement)appointment.Parent, false);
                    }
                    else
                    {
                        this.Scheduler.Cursor = Cursors.Default;
                    }
                }

                return false;
            }
            private void SelectCell(SchedulerCellElement cell, bool extend)
            {
                this.Scheduler.SelectionBehavior.SelectCell(cell, extend);
            }
        }

this.radScheduler1.SchedulerInputBehavior = new CustomSchedulerInputBheavior(this.radScheduler1);

Completed
Last Updated: 06 Jun 2019 13:27 by ADMIN
Release R2 2019 SP1 (LIB 2019.2.610)
Completed
Last Updated: 03 Oct 2019 11:50 by ADMIN
Release R3 2019 SP1 (LIB 2019.3.1007)
Created by: Andrea
Comments: 3
Category: Scheduler/Reminder
Type: Bug Report
1

Hi,

using a RadScheduler into a desktop application. It seems like, on mouse-down event happening into a cell of the first row, the grid of the scheduler is shifting down of a row, resulting in the mouse handle being on the previous row's cell. No mouse wheel scrolled, no other mouse movement. Just one left-click. The result is that on mouse-up we are in a different cell and our event-handler is getting confused.

Sorry for not having any code snippet, I just attach a video of what's happening. Consider that I have only positioned the mouse on the cell at 8am and left-clicked. Tested also with version 2019.2.508 (even though in our app we are still using 2016.2.608).

Thanks in advance and best regards,

Emanuele Nava
Apogeo srl
Italy

 

Completed
Last Updated: 15 Feb 2019 17:02 by ADMIN

Hello,

We have developed an ASP.NET application and a WinForms application that both uses Telerik RadScheduler. The applications share the same data.

We have set EnableExactTimeRendering = true to prevent appointments to falsely be displayed as collisions.

Our problem is that appointments with short durations (0-4 minutes) are totally invisible in the WinForms Scheduler. In the ASP.NET scheduler all appointments are visible. An appointment with no duration (0 minutes) is shown as 30min appointment in ASP.NET while 1-minute appointments are shown as a thin line which is ok as we use tooltips for all appointments.

How can we make all appointments visible in WinForms and still use EnableExactTimeRendering? Of course, the rendering will not be exact for small durations but that is better than not showing the appointments at all. We would like to set a minimum size for appointments.

Best regards,
Daniel Gidlöf

 

Completed
Last Updated: 17 Dec 2018 16:35 by Dimitar
To reproduce:  

1.Change the first day of week to Monday:

            SchedulerMonthView view = new SchedulerMonthView();
            CultureInfo ci = new CultureInfo("en-US");
 
            ci.DateTimeFormat.FirstDayOfWeek = DayOfWeek.Monday;
            view.CurrentCulture = ci;
            this.radScheduler1.ActiveView = view;
2. Create an appointment with a recurrence rule illustrated in the attached screenshot. Imagine that today is Wednesday and the recurrence rule starts on Monday from the same week.
As a result, you will notice that the WeeklyRecurrenceRule.FirstDayOfWeek is not set and the appointment occurs on the wrong Sundays. Refer to the attached screenshot. 

Workaround:

        private void radScheduler1_AppointmentAdded(object sender, AppointmentAddedEventArgs e)
        {
            if (e.Appointment.RecurrenceRule != null)
            {
                WeeklyRecurrenceRule r = e.Appointment.RecurrenceRule as WeeklyRecurrenceRule;
                r.FirstDayOfWeek = DayOfWeek.Monday;
            }
        }
Completed
Last Updated: 03 Dec 2018 17:21 by Dimitar
How to reproduce: check the attached (video radscheduler-selection-incorrect.gif)
 public RadForm1()
 {
     InitializeComponent();

     Appointment appointment = new Appointment(DateTime.Today.AddHours(13), TimeSpan.FromHours(1), "Test Appointment");
     this.radScheduler1.Appointments.Add(appointment);

     for (int i = 0; i < 25; i++)
     {
         appointment = new Appointment(DateTime.Today.AddHours(24), TimeSpan.FromHours(1), "AllDay: " + i);
         appointment.AllDay = true;
         this.radScheduler1.Appointments.Add(appointment);
     }
     this.radScheduler1.AllowAppointmentsMultiSelect = true;
 }

Workaround: create a custom input behavior

this.radScheduler1.SchedulerInputBehavior = new CustomSchedulerInputBehavior(this.radScheduler1);

public class CustomSchedulerInputBehavior : SchedulerInputBehavior
{
    public CustomSchedulerInputBehavior(RadScheduler scheduler) 
        : base(scheduler)
    {
    }

    public override bool HandleMouseWheel(MouseEventArgs args)
    {
        if (!this.Scheduler.AllowMouseWheelSupport)
            return false;

        bool scrolled = false;

        if (this.Scheduler.SelectionBehavior.IsAllDayAreaSelection || this.IsLastSelectedAppointmentAllDay(this.Scheduler.SelectionBehavior.SelectedAppointments))
        {
            if (this.Scheduler.GroupType == GroupType.Resource)
            {
                SchedulerDayViewGroupedByResourceElement grouped = this.Scheduler.ViewElement as SchedulerDayViewGroupedByResourceElement;
                IList<SchedulerDayViewElement> childViews = grouped != null ? grouped.GetChildViewElements() : null;
                if (childViews != null && childViews.Count > 0)
                {
                    RadScrollBarElement scroll = childViews[childViews.Count - 1].AllDayHeaderElement.ScrollBar;
                    if (scroll.Visibility != ElementVisibility.Collapsed)
                    {
                        int newValue = scroll.Value - childViews[childViews.Count - 1].AllDayHeaderElement.HeaderHeight * Math.Sign(args.Delta);
                        newValue = Math.Max(Math.Min(newValue, scroll.Maximum - scroll.LargeChange + 1), scroll.Minimum);
                        scroll.Value = newValue;
                        scrolled = true;
                    }
                }
            }
            else
            {
                SchedulerDayViewElement dayView = this.Scheduler.ViewElement as SchedulerDayViewElement;
                RadScrollBarElement scroll = dayView != null ? dayView.AllDayHeaderElement.ScrollBar : null;

                if (scroll != null && scroll.Visibility != ElementVisibility.Collapsed)
                {
                    int newValue = scroll.Value - dayView.AllDayHeaderElement.HeaderHeight * Math.Sign(args.Delta);
                    newValue = Math.Max(Math.Min(newValue, scroll.Maximum - scroll.LargeChange + 1), scroll.Minimum);
                    scroll.Value = newValue;
                    scrolled = true;
                }
            }
        }

        if (scrolled)
        {
            return false;
        }

        if (args.Delta > 0)
        {
            this.Scheduler.ViewElement.Scroll(true);
        }
        else
        {
            this.Scheduler.ViewElement.Scroll(false);
        }
        return false;
    }

    private bool IsLastSelectedAppointmentAllDay(ReadOnlyCollection<IEvent> selectedAppointments)
    {
        if (selectedAppointments.Count > 0)
        {
            return selectedAppointments[selectedAppointments.Count - 1].AllDay;
        }

        return false;
    }

}

1 2 3 4 5 6