Device.ewu

$version 12.00

$rect <320,140,490,180>
$output false
class Contact
{
  $rect <480,140,680,180>
  inherited method Init()
  {
    pure ID = Device::Device.GetNewID();

    attachobserver notifyThis, ^MessagesList.NoOfItems;

  }

  $rect <0,60,200,100>
  property string FirstName;

  $rect <0,10,200,50>
  var Device::Contact next;

  $rect <0,100,200,140>
  property string LastName;

  $rect <470,30,670,70>
  method void TraceContact()
  {
    trace FirstName + " " + LastName;
  }

  $rect <0,140,200,180>
  property string PhoneNumber;

  $rect <200,60,400,100>
  onset FirstName
  {
    // The value doesn't change - nothing to do.
    if ( pure FirstName == value )
      return;

    // Remember the property's new value.
    pure FirstName = value;

    notifyobservers this;
  }

  $rect <200,100,400,140>
  onset LastName
  {
    // The value doesn't change - nothing to do.
    if ( pure LastName == value )
      return;

    // Remember the property's new value.
    pure LastName = value;

    notifyobservers this;
  }

  $rect <200,140,400,180>
  onset PhoneNumber
  {
    // The value doesn't change - nothing to do.
    if ( pure PhoneNumber == value )
      return;

    // Remember the property's new value.
    pure PhoneNumber = value;

    notifyobservers this;
  }

  $rect <0,180,200,220>
  property string NameInitials;

  $rect <200,180,400,220>
  onset NameInitials
  {
    // The value doesn't change - nothing to do.
    if ( pure NameInitials == value )
      return;

    // Remember the property's new value.
    pure NameInitials = value;

    notifyobservers this;
  }

  $rect <0,260,200,300>
  property int32 ID = 0;

  $rect <200,260,400,300>
  onset ID
  {
    // The value doesn't change - nothing to do.
    if ( pure ID == value )
      return;

    // Remember the property's new value.
    pure ID = value;


  }

  $rect <470,80,670,120>
  method Device::Contact CopyDataTo( arg Device::Contact aContact )
  {
    aContact.ID           = ID;
    aContact.LastName     = LastName;
    aContact.FirstName    = FirstName;
    aContact.PhoneNumber  = PhoneNumber;
    aContact.NameInitials = NameInitials;

    return aContact;
  }

  $rect <0,220,200,260>
  property bool IsFavorite;

  $rect <200,220,400,260>
  onset IsFavorite
  {
    // The value doesn't change - nothing to do.
    if ( pure IsFavorite == value )
      return;

    // Remember the property's new value.
    pure IsFavorite = value;

    notifyobservers this;
  }

  $rect <0,300,200,340>
  property bool IsMyCard = false;

  $rect <200,300,400,340>
  onset IsMyCard
  {
    // The value doesn't change - nothing to do.
    if ( pure IsMyCard == value )
      return;

    // Remember the property's new value.
    pure IsMyCard = value;

    notifyobservers this;
  }

  $rect <0,380,200,420>
  object Device::MessagesList MessagesList;

  $rect <0,340,200,380>
  property int32 UnreadMessagesNr = 0;

  $rect <200,340,400,380>
  onset UnreadMessagesNr
  {
    // The value doesn't change - nothing to do.
    if ( pure UnreadMessagesNr == value )
      return;

    // Remember the property's new value.
    pure UnreadMessagesNr = value;

    notifyobservers this;
  }

  $rect <480,190,680,230>
  slot notifyThis
  {
    notifyobservers this;
  }
}

// Contact
note group Note2
{
  attr Bounds = <300,0,810,360>;
}

$rect <570,180,780,220>
$output false
enum Sorting
{
  $rect <10,10,210,50>
  item None;

  $rect <220,10,420,50>
  item Ascending;

  $rect <430,10,630,50>
  item Descending;
}

$rect <20,40,250,80>
$output false
class DeviceClass : Templates::DeviceClass
{
  $rect <0,40,200,80>
  inherited method Done()
  {
    // The following section is intended to perform de-initialization-related operations
    // in the underlying device or middleware. Consequently, the section is taken in
    // account only when generating code (not during prototyping).
    $if !$prototyper
      var object thisObject = this;

      /*
         TO DO:

         The following native statement is intended to enclose code to communicate with
         your device API. The variable 'thisObject' contains a pointer to the actually
         de-initialized Device::DeviceClass object. Use the 'thisObject' pointer to
         e.g. de-register the object from the middleware if you have registered it
         beforehand.
         
      */

      native ( thisObject )
      {
        /*
           TO DO:

           Depending on your application case you call functions of the underlying
           middleware (or access the device directly) in order to perform the necessary
           de-initialization steps. For example, you invoke some 'C' function:

             YourDevice_DeInitialize();

           IMPORTANT:
           ----------

           The variable 'thisObject' represents the actually de-initialized instance of the
           Device::DeviceClass. If you have stored this object at the initialization
           time (in the 'Init' method) in some global C variable or registered it by the
           middleware, it is important to perform now the opposite operation. Set the
           global variable to NULL or de-register 'thisObject' object from the middleware.
           
        */
      }
    $endif
  }

  $rect <0,0,200,40>
  inherited method Init()
  {
    // The following section is intended to perform initialization-related operations
    // in the underlying device or middleware. Consequently, the section is taken in
    // account only when generating code (not during prototyping).
    $if !$prototyper
      var object thisObject = this;

      /*
         TO DO:

         The following native statement is intended to enclose code to communicate with
         your device API. The variable 'thisObject' contains a pointer to the actually
         initialized Device::DeviceClass object. Use the 'thisObject' pointer to
         e.g. register the object by the middleware as receiver of events, etc.
         
      */

      native ( thisObject )
      {
        /*
           TO DO:

           Depending on your application case you call functions of the underlying
           middleware (or access the device directly) in order to perform the necessary
           initialization steps. For example, you invoke some 'C' function:

             YourDevice_Initialize();

           The variable 'thisObject' represents the actually initialized instance of the
           Device::DeviceClass. You can store this variable e.g. in the middleware
           and use it whenever the middleware needs to notify the GUI application about
           some state alternation or events. In this manner, the middleware will be able
           to invoke methods of the interface device object.

           For example, you can store 'thisObject' in some global C variable:

             // Declaration of the global C variable
             XObject theDeviceObject;

             // Store the instance in the global variable
             theDeviceObject = thisObject;

           Later use the global variable e.g. to provide the GUI application with events:

             ApplicationDeviceClass__TriggerSomeEvent( theDeviceObject );

           IMPORTANT:
           ----------

           If you store 'thisObject' for later use, don't forget to implement the opposite
           operation in the method 'Done'. Concrete, 'Done' should set the global variable
           again to the value NULL.

        */
      }
    $endif
  }

  $rect <200,90,400,130>
  property bool Microphone;

  $rect <600,90,800,130>
  onget Microphone
  {
    // Per default return the value stored already in the property.
    return pure Microphone;

    /*

      TO DO:

      If the property should return the value stored in the underlying device
      or in the middleware, remove the above 'return' statement and instead do
      following:

      Declare a local variable to receive the value from the underlying device.
      The type of the variable has to correspond to the data type of the property.
      For example in case of an 'int32' property:
      
        var int32 result;

      Implement a native statement to access the value and to store it in the
      variable 'result'. Then return the value. For example:

        $if !$prototyper
          native ( result )
          {
            result = YourDevice_GetSomeValue();
          }
        $endif

        return result;

    */
  }

  $rect <400,90,600,130>
  onset Microphone
  {
    // The property doesn't change -> nothing to do.
    if ( pure Microphone == value )
      return;

    // Remember the new value in the internal memory of the property.
    pure Microphone = value;

    // For target code generation you will use your specific device API 
    // to change the affected value.
    $if !$prototyper
      native ( value )
      {
        /*
           TO DO:

           You can call a function of your own device API or you simply
           modify a variable existing in your middleware to reflect the
           new value:

           YourDevice_SetSomeValue( value );

           or

           YourDevice_SomeVariable = value;
        */
      }
    $endif

    // Notify all associated property observers.
    notifyobservers ^Microphone;
  }

  // This method is intended to be called by the device to notify the GUI application \
  // about an alternation of its setting or state value.
  $rect <0,90,200,130>
  $output true
  method void UpdateMicrophone( arg bool aNewValue )
  {
    // Only if the reported value does differ from the one stored currently in the property.
    if ( aNewValue != pure Microphone )
    {
      // Remember the new value in the internal memory of the property.
      pure Microphone = aNewValue;

      // Notify all associated property observers.
      notifyobservers ^Microphone;
    }
  }

  $rect <200,130,400,170>
  property bool Speaker;

  $rect <600,130,800,170>
  onget Speaker
  {
    // Per default return the value stored already in the property.
    return pure Speaker;

    /*

      TO DO:

      If the property should return the value stored in the underlying device
      or in the middleware, remove the above 'return' statement and instead do
      following:

      Declare a local variable to receive the value from the underlying device.
      The type of the variable has to correspond to the data type of the property.
      For example in case of an 'int32' property:
      
        var int32 result;

      Implement a native statement to access the value and to store it in the
      variable 'result'. Then return the value. For example:

        $if !$prototyper
          native ( result )
          {
            result = YourDevice_GetSomeValue();
          }
        $endif

        return result;

    */
  }

  $rect <400,130,600,170>
  onset Speaker
  {
    // The property doesn't change -> nothing to do.
    if ( pure Speaker == value )
      return;

    // Remember the new value in the internal memory of the property.
    pure Speaker = value;

    // For target code generation you will use your specific device API 
    // to change the affected value.
    $if !$prototyper
      native ( value )
      {
        /*
           TO DO:

           You can call a function of your own device API or you simply
           modify a variable existing in your middleware to reflect the
           new value:

           YourDevice_SetSomeValue( value );

           or

           YourDevice_SomeVariable = value;
        */
      }
    $endif

    // Notify all associated property observers.
    notifyobservers ^Speaker;
  }

  // This method is intended to be called by the device to notify the GUI application \
  // about an alternation of its setting or state value.
  $rect <0,130,200,170>
  $output true
  method void UpdateSpeaker( arg bool aNewValue )
  {
    // Only if the reported value does differ from the one stored currently in the property.
    if ( aNewValue != pure Speaker )
    {
      // Remember the new value in the internal memory of the property.
      pure Speaker = aNewValue;

      // Notify all associated property observers.
      notifyobservers ^Speaker;
    }
  }

  $rect <0,490,200,530>
  object Device::ContactsList Contacts;

  $rect <0,570,200,610>
  object Device::ContactsList History;

  $rect <0,530,200,570>
  object Device::ContactsList Favorites;

  $rect <200,190,400,230>
  method void SendCallFromContact( arg Device::Contact aContact )
  {
    var Device::HistoryContact historyContact = new Device::HistoryContact;

    aContact.CopyDataTo( historyContact );

    historyContact.TimeOfCall    = (new Core::Time).CurrentTime;
    historyContact.CallState     = Device::CallState.Dialing;
    historyContact.CallDirection = Device::CallDirection.Outgoing;

    OngoingCalls.AddLast( historyContact );

    // if call fails
    if ( ! Device::PhoneServer.StartCall( historyContact.PhoneNumber ))
    {
      historyContact.CallState = Device::CallState.Missed;
      
      History.AddFirst( historyContact );
      OngoingCalls.Remove( historyContact );
    }
  }

  $rect <0,210,200,250>
  method void ReceiveCall( arg string aPhoneNumber )
  {
    var Device::Contact contact               = Contacts.FindByPhoneNumber( aPhoneNumber );
    var Device::HistoryContact historyContact = new Device::HistoryContact;

    //contact not found in contact list, than save it by number
    if ( contact == null )
    {
      historyContact.LastName    = aPhoneNumber;
      historyContact.PhoneNumber = aPhoneNumber;
    }
    else
    {
      contact.CopyDataTo( historyContact );
    }

    historyContact.TimeOfCall    = (new Core::Time).CurrentTime;
    historyContact.CallState     = Device::CallState.Dialing;
    historyContact.CallDirection = Device::CallDirection.Incoming;

    OngoingCalls.AddLast( historyContact );


  }

  $rect <200,230,400,270>
  method void SendCallFromNumber( arg string aPhoneNumber )
  {
    var Device::Contact contact               = Contacts.FindByPhoneNumber( aPhoneNumber );
    var Device::HistoryContact historyContact = new Device::HistoryContact;

    if ( contact == null )
    {
      historyContact.LastName    = aPhoneNumber;
      historyContact.PhoneNumber = aPhoneNumber;
    } 
    else
    {
      contact.CopyDataTo( historyContact );
    }

    historyContact.TimeOfCall    = (new Core::Time).CurrentTime;
    historyContact.CallState     = Device::CallState.Dialing;
    historyContact.CallDirection = Device::CallDirection.Outgoing;

    OngoingCalls.AddLast( historyContact );

    /// if call fails
    if ( ! Device::PhoneServer.StartCall( historyContact.PhoneNumber ))
    {
      historyContact.CallState = Device::CallState.Missed;
      
      History.AddFirst( historyContact );
      OngoingCalls.Remove( historyContact );
    }

  }

  $rect <200,570,400,610>
  object Device::ContactsList OngoingCalls;

  $rect <500,490,700,530>
  method int32 GetNewID()
  {
    LastID +=1;

    return LastID;

  }

  $rect <700,490,900,530>
  var int32 LastID = 0;

  $rect <200,350,400,390>
  method void SendEndCall( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );

    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
       
    if ( historyContact.CallState == Device::CallState.Dialing )
    {
       historyContact.CallState = Device::CallState.Cancelled; 
       
       Device::PhoneServer.CancelledCall( historyContact.PhoneNumber ); 
    }  
      
    else if ( historyContact.CallState == Device::CallState.Speaking )
    {
      historyContact.CallState = Device::CallState.EndCall;
      historyContact.EndTime   = (new Core::Time).CurrentTime;
      
      Device::PhoneServer.EndCall( historyContact.PhoneNumber );
    } 


    History.AddFirst( historyContact );
    OngoingCalls.Remove( historyContact );

  }

  $rect <200,270,400,310>
  method void SendCallAnswer( arg Device::HistoryContact aContact )
  {
    aContact.CallState = Device::CallState.Speaking;
    aContact.StartTime = (new Core::Time).CurrentTime;

    if( !Device::PhoneServer.AnswerCall( aContact.PhoneNumber ))
    {
      aContact.CallState = Device::CallState.Missed;
      
      History.AddFirst( aContact );
      OngoingCalls.Remove( aContact );
     }
    //esetleg ha megszakad a vonal akkor tegye be fail


  }

  $rect <0,270,200,310>
  method void ReceiveCallAnswered( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );

    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
      
    historyContact.CallState = Device::CallState.Speaking;
    historyContact.StartTime = (new Core::Time).CurrentTime;

  }

  $rect <0,310,200,350>
  method void ReceiveCallRejected( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );

    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
     
    if ( historyContact.CallState == Device::CallState.Dialing )
    {
      historyContact.CallState = Device::CallState.Rejected;
    }

    History.AddFirst( historyContact );
    OngoingCalls.Remove( historyContact );

  }

  $rect <200,310,400,350>
  method void SendCallRejected( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );

    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
      
    if ( historyContact.CallState == Device::CallState.Dialing )
    {
      historyContact.CallState = Device::CallState.Rejected;
    }

    Device::PhoneServer.RejectCall( historyContact.PhoneNumber );

    History.AddFirst( historyContact );
    OngoingCalls.Remove( historyContact );

  }

  $rect <0,350,200,390>
  method void ReceiveEndCall( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );
     
    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
      
    if ( historyContact.CallState == Device::CallState.Dialing )
    {
       historyContact.CallState = Device::CallState.Cancelled; 
    }  
      
    else if ( historyContact.CallState == Device::CallState.Speaking )
    {
      historyContact.CallState = Device::CallState.EndCall;
      historyContact.EndTime   = (new Core::Time).CurrentTime;
    } 


    History.AddFirst( historyContact );
    OngoingCalls.Remove( historyContact );

  }

  $rect <880,-10,1080,30>
  var Device::PhoneServerClass server = Device::PhoneServer;

  $rect <900,100,1100,140>
  property Device::Contact MyContact = null;

  $rect <900,140,1100,180>
  onset MyContact
  {
    if ( pure MyContact == value )
      return;

    pure MyContact = value;

    if ( pure MyContact != null )
    {
      signal Device::PhoneServer.PollServerData.StartTimer;
    }

    notifyobservers ^MyContact;

    trace "MyCard: " + MyContact.FirstName + MyContact.LastName + MyContact.PhoneNumber;
  }

  $rect <480,190,680,230>
  method void ReceiveMessage( arg string aSenderNumber, arg string aMessageContent )
  {
    //megnezem ha megkapom a contactot meglevo beszelgetesek kozott
    var Device::Contact contactSender = MessageHistory.FindByPhoneNumber( aSenderNumber );

    //ha nem akkor megkeresem a contactlistaba
    if ( contactSender == null )
    {
      var Device::Contact contact = Contacts.FindByPhoneNumber( aSenderNumber );
      
      if ( contact == null )
      {
        contact = new Device::Contact;
      
        contact.FirstName    = aSenderNumber;
        contact.PhoneNumber  = aSenderNumber;
        contact.NameInitials = Contacts.GetInitials( aSenderNumber, "" ); 
       }
       contactSender = contact;
    }
    //ha igen akkor kiveszem a beszelgetesekbol
    else 
    {
      MessageHistory.Remove( contactSender );
    }

    //letre hozok egy uzenetet
    var Device::Message message = new Device::Message;

    message.Sender   = contactSender;
    message.Receiver = MyContact;
    message.TimeSent = ( new Core::Time).CurrentTime;
    message.MessageContent  = aMessageContent;
    message.IsSeen     = false;

    //hozza rendeleme az uzenetet a contacthoz
    contactSender.MessagesList.Add( message );

    contactSender.UnreadMessagesNr ++;
    //hozza adom az uj/frissitett contactot a beszelgetesekhez
    MessageHistory.AddFirst( contactSender );

    MessageHistory.FindUnreadMessagesNr();
  }

  $rect <670,190,870,230>
  method void SendMessage( arg Device::Contact aContact, arg string aMessageContent )
  {
    //letre hozom az uzenetet
     var Device::Message message = new Device::Message;

    message.Sender   = MyContact;
    message.Receiver = aContact;
    message.TimeSent = ( new Core::Time).CurrentTime;
    message.MessageContent  = aMessageContent;
    message.IsSeen     = true;

    //hozza rendelem a contachoz
    aContact.MessagesList.Add( message );

    //megnezem ha megkapom a contactot a meglevo beszelgetesek kozott
    var Device::Contact contact = MessageHistory.FindMatchingIDContact( aContact );

    //ha igen kitrolom
    if ( contact != null )
    {
      MessageHistory.Remove( aContact );
    }
    //hozza adom az uj/frissitett contactot a beszelgetesekhez
    MessageHistory.AddFirst( aContact );

    trace "Device/SendMessage: " + aContact.PhoneNumber + " " + aMessageContent;

    Device::PhoneServer.SendMessage( aContact.PhoneNumber, aMessageContent );



  }

  $rect <0,610,200,650>
  object Device::HistoryMessagesList MessageHistory;

  $rect <0,390,200,430>
  method void ReceiveMissedCall( arg string aPhoneNumber )
  {
    var Device::HistoryContact historyContact = (Device::HistoryContact)Device::Device.OngoingCalls.GetContactAtIndex( 0 );

    if ( historyContact.PhoneNumber != aPhoneNumber )
      return;
       
    if ( historyContact.CallState == Device::CallState.Dialing )
    {
       historyContact.CallState = Device::CallState.Missed; 
       historyContact.EndTime   = (new Core::Time).CurrentTime;
    }  

    History.AddFirst( historyContact );
    OngoingCalls.Remove( historyContact );
  }

  $rect <200,490,380,530>
  object Device::ContactsList FilteredContacts;
}

$rect <20,80,250,120>
autoobject Device::DeviceClass Device;

// Device
note group Note3
{
  attr Bounds = <0,0,290,200>;
}

$rect <550,140,750,180>
$output false
enum CallState
{
  $rect <10,10,210,50>
  item None;

  $rect <10,130,210,170>
  item Missed;

  $rect <10,170,210,210>
  item Cancelled;

  $rect <15,65,215,105>
  item Dialing;

  $rect <10,210,210,250>
  item Rejected;

  $rect <10,264,210,304>
  item Speaking;

  $rect <260,170,460,210>
  item EndCall;

  $rect <250,70,450,110>
  item Fail;
}

$rect <20,130,250,170>
$variant $SimulateData
vclass DeviceSimulation : Device::DeviceClass
{
  $rect <0,0,200,40>
  inherited method Init()
  {
    postsignal CreateContactData;
  }

  $rect <0,90,200,130>
  method void CreateContact( arg string aLastName, arg string aFirstName, arg string aPhoneNumber )
  {
    var Device::Contact contact = new Device::Contact;

    contact.FirstName    = aFirstName;
    contact.LastName     = aLastName;
    contact.PhoneNumber  = aPhoneNumber;
    contact.NameInitials = Contacts.GetInitials( aLastName, aFirstName );
    Contacts.AddLast( contact );


  }

  $rect <0,130,200,170>
  method void CreateContactFav( arg string aLastName, arg string aFirstName, arg string aPhoneNumber )
  {
    var Device::Contact contact = new Device::Contact;   

    contact.FirstName = aFirstName;
    contact.LastName = aLastName;
    contact.PhoneNumber = aPhoneNumber;
    contact.NameInitials = Favorites.GetInitials( aLastName, aFirstName );
    Favorites.AddLast( contact );



  }

  $rect <0,170,200,210>
  method void CreateContact2( arg string aLastName, arg string aFirstName, arg string aPhoneNumber )
  {
    var Device::HistoryContact contact = new Device::HistoryContact;


    contact.FirstName = aFirstName;
    contact.LastName = aLastName;
    contact.PhoneNumber = aPhoneNumber;
    contact.CallState = Device::CallState.Dialing;
    History.AddFirst( contact );



  }

  $rect <0,50,200,90>
  slot CreateContactData
  {
    CreateContact( "Smith", "Noah", "0723");
    CreateContact(  "Jones", "Oliver", "0745");
    CreateContact(  "Williams", "Amelia", "0759876234");
    CreateContact(  "Taylor", "Leo", "0713243546");
    CreateContact( "Brown", "Nancy", "0754981234");
    CreateContact(  "Davies", "James", "0756788890");
    CreateContact(  "Addison", "Michaek", "0740987662");
    CreateContact(  "Kennedy", "Jane", "0755545654");
    Contacts.insertionSort();

    Contacts.CancelSearch();

    //postsignal Message;
  }

  $rect <40,275,240,315>
  slot Message
  {
    var Device::Message msg = new Device::Message;

    var Device::Contact cont = new Device::Contact;

    cont.FirstName = "smith";
    cont.LastName = "noah";
    cont.PhoneNumber = "12";
    cont.NameInitials ="sn";

    var Device::Contact cont1 = new Device::Contact;

    cont1.FirstName = "amy";
    cont1.LastName = "bruce";
    cont1.PhoneNumber = "22";
    cont1.NameInitials ="ab";


    msg.Sender = cont;
    msg.Receiver = cont1;
    msg.MessageContent = "hello";

    cont1.MessagesList.Add( msg );




    Device::Device.MessageHistory.AddFirst( cont1 );
  }
}

$rect <350,180,520,220>
$output false
class HistoryContact : Device::Contact
{
  $rect <10,40,210,80>
  property Device::CallState CallState = Device::CallState.None;

  $rect <210,40,410,80>
  onset CallState
  {
    // The value doesn't change - nothing to do.
    if ( pure CallState == value )
      return;

    // Remember the property's new value.
    pure CallState = value;

    notifyobservers this;
  }

  $rect <10,120,210,160>
  property Core::Time TimeOfCall;

  $rect <210,120,410,160>
  onset TimeOfCall
  {
    // The value doesn't change - nothing to do.
    if ( pure TimeOfCall == value )
      return;

    // Remember the property's new value.
    pure TimeOfCall = value;

    notifyobservers this;
  }

  $rect <10,160,210,200>
  property Core::Time StartTime = null;

  $rect <210,160,410,200>
  onset StartTime
  {
    // The value doesn't change - nothing to do.
    if ( pure StartTime == value )
      return;

    // Remember the property's new value.
    pure StartTime = value;

    notifyobservers this;
  }

  $rect <10,80,210,120>
  property Device::CallDirection CallDirection = Device::CallDirection.None;

  $rect <210,80,410,120>
  onset CallDirection
  {
    // The value doesn't change - nothing to do.
    if ( pure CallDirection == value )
      return;

    // Remember the property's new value.
    pure CallDirection = value;

    notifyobservers this;
  }

  $rect <10,200,210,240>
  property Core::Time EndTime = null;

  $rect <210,200,410,240>
  onset EndTime
  {
    // The value doesn't change - nothing to do.
    if ( pure EndTime == value )
      return;

    // Remember the property's new value.
    pure EndTime = value;

    notifyobservers this;
  }

  $rect <420,180,620,220>
  method string GetDuration()
  {
    var Core::TimeSpan time = new Core::TimeSpan;
    if ( StartTime == null )
      return "";
      
    else if ( EndTime == null )
    {
      time = (new Core::Time).CurrentTime.Difference( StartTime );
     }
    else
    {
      time = EndTime.Difference( StartTime );
    }

    if ( time.TotalMinutes < 1 )
      return time.Format( "%S seconds" );

    if ( time.TotalMinutes < 60 )
      return time.Format( "%M:%S minutes" );
      
    else
      return time.Format( "%H:%M:%S houres" );
  }

  $rect <420,40,620,80>
  method string GetCallState()
  {
    switch ( CallState )
    {
      case Device::CallState.Cancelled: return Strings::CancelledTxt;

      case Device::CallState.Missed: return Strings::MissedTxt;
      
      case Device::CallState.Rejected: return Strings::RejectedTxt;

      default: 
        return Strings::ErrorTxt;
    }
  }

  $rect <420,80,620,120>
  method string GetCallDirection()
  {
    switch ( CallDirection )
    {
      case Device::CallDirection.Incoming: return Strings::IncomingTxt;

      case Device::CallDirection.Outgoing: return Strings::OutgoingTxt;

      default:
        return Strings::ErrorTxt;
    }
  }

  $rect <420,120,620,160>
  method string GetTimeOfCall()
  {
    var Core::TimeSpan time = new Core::TimeSpan;
    if ( TimeOfCall == null )
      return "";

    time = (new Core::Time).CurrentTime.Difference( TimeOfCall );
    if ( time.TotalHours < 24)
      return TimeOfCall.Format( "%H:%M %p" );

    if ( TimeOfCall.Day < (new Core::Time).CurrentTime.Day)
      return TimeOfCall.Format( "%w" );
      
    else
      return TimeOfCall.Format( "%d:%m:%y" );
  }
}

$rect <350,80,530,120>
$output false
class ContactListElement
{
  $rect <0,10,200,50>
  var Device::ContactListElement next = null;

  $rect <230,10,430,50>
  method void TraceContact()
  {
    //trace FirstName + " " + LastName;
  }

  $rect <0,50,200,90>
  var Device::Contact Data = null;
}

$rect <320,40,500,80>
$output false
class ContactsList
{
  $rect <0,0,200,40>
  var Device::ContactListElement head = null;

  $rect <0,50,200,90>
  method void AddLast( arg Device::Contact aContact )
  {
    var Device::ContactListElement elem = new Device::ContactListElement;
    elem.Data = aContact;

    if ( head ==  null )
    {  
      head = elem; 
    }  
    else
    {
      // add contact after the last node
      var Device::ContactListElement lastNode = head;
      while ( lastNode.next != null )
      {
        lastNode = lastNode.next;
      }

      lastNode.next = elem;
    }

    NoOfItems +=1;

  }

  $rect <0,130,200,170>
  method void Remove( arg Device::Contact aContact )
  {
    var Device::ContactListElement elem = head;
    var Device::ContactListElement prev = null;

    if (( elem != null) && ( elem.Data == aContact ))
    {
      head = elem.next;
      NoOfItems -= 1;
    }
     
    else
    {
      while ((elem != null) && (elem.Data != aContact))
      {
        prev = elem;
        elem = elem.next;
       }
       prev.next = elem.next;
       NoOfItems -= 1;
    }

  }

  $rect <0,290,200,330>
  method void TraceContacts()
  {
    var Device::ContactListElement elem = head;

    while ( elem.Data != null )
    {
      elem.TraceContact();
      elem = elem.next;
    }

  }

  $rect <210,0,410,40>
  property int32 NoOfItems = 0;

  $rect <210,40,410,80>
  onset NoOfItems
  {
    // The value doesn't change - nothing to do.
    if ( pure NoOfItems == value )
      return;

    // Remember the property's new value.
    pure NoOfItems = value;

    notifyobservers ^NoOfItems;

  }

  $rect <0,170,200,210>
  method Device::Contact GetContactAtIndex( arg int32 aIndex )
  {
    if ( head == null || aIndex >= NoOfItems )
      return null;
      
    var Device::ContactListElement elem = head;
    var int32 it = 0;
    while ( it != aIndex && elem.Data != null )
    {
      elem = elem.next;
      it += 1;
    }
    return elem.Data;

  }

  $rect <860,0,1060,40>
  method string GetInitials( arg string aLastname, arg string aFirstname )
  {
     return ( ( aLastname != "" ) ? aLastname[0] : "" ) + 
            ( ( aFirstname != "" ) ? aFirstname[0] : "" );
  }

  $rect <430,80,630,120>
  method void insertionSort()
  {
    var Device::ContactListElement current = head;

    while ( current != null )
    {
      //store the currents next for next iteration 
      var Device::ContactListElement next = current.next;
      //insert cuurent in sorted liked list
      sortedInsert ( current );

      //update current 
      current = next;
    }

    head = sorted;
    sorted = null;
  }

  $rect <430,40,630,80>
  method void sortedInsert( arg Device::ContactListElement aElement )
  {
    if ((sorted == null) || 
        ((Sorting == Device::Sorting.Ascending)  && (sorted.Data.LastName >= aElement.Data.LastName )) ||
        ((Sorting == Device::Sorting.Descending) && (sorted.Data.LastName <= aElement.Data.LastName)))
    {
      aElement.next = sorted;
      sorted = aElement;
    }

    else
    {
      var Device::ContactListElement current = sorted;

      
     while (( current.next != null) &&
              (((Sorting == Device::Sorting.Ascending) && (current.next.Data.LastName < aElement.Data.LastName)) ||
              ((Sorting == Device::Sorting.Descending) && (current.next.Data.LastName > aElement.Data.LastName))))
      {
        current = current.next;
      }
      aElement.next = current.next;
      current.next  = aElement;
    }


  }

  $rect <430,0,630,40>
  var Device::ContactListElement sorted = null;

  $rect <640,0,840,40>
  property Device::Sorting Sorting = Device::Sorting.None;

  $rect <640,40,840,80>
  onset Sorting
  {
    // The value doesn't change - nothing to do.
    if ( pure Sorting == value )
      return;

    // Remember the property's new value.
    pure Sorting = value;

    insertionSort();
    notifyobservers ^Sorting;
  }

  $rect <0,250,200,290>
  method Device::Contact FindByPhoneNumber( arg string aNumber )
  {
    var Device::ContactListElement elem = head;

    while ( elem != null )
    {
      if( elem.Data.PhoneNumber == aNumber )
        return elem.Data;
      elem = elem.next;
    }

    return null; 
     

  }

  $rect <0,210,200,250>
  method Device::Contact FindMatchingIDContact( arg Device::Contact aContact )
  {
    if ( head != null )
    {
      var Device::ContactListElement elem = head;  

      while ( elem != null )
      {
        if ( elem.Data.ID == aContact.ID )
          return elem.Data;
        
        elem = elem.next;
      }
    }
    return null;
  }

  $rect <0,90,200,130>
  method void AddFirst( arg Device::Contact aContact )
  {
    var Device::ContactListElement elem = new Device::ContactListElement;
    elem.Data = aContact;


    elem.Data = aContact;
    elem.next = head;
    head = elem;

    NoOfItems += 1;

  }

  $rect <200,130,400,170>
  method void RemoveAll()
  {
    head = null;
    NoOfItems = 0;
  }

  $rect <210,210,410,250>
  method Device::Contact FindContactByID( arg int32 aID )
  {
    if ( head != null )
    {
      var Device::ContactListElement elem = head;

      while ( elem != null )
      {
        if ( elem.Data.ID == aID )
          return elem.Data;
        
        elem = elem.next;
      }
    }
    return null;
  }

  $rect <630,170,830,210>
  method void Search( arg string aText )
  {
    if ( head != null )
    {
      var Device::ContactListElement elem = head;
      aText = aText.lower;

      Device::Device.FilteredContacts.RemoveAll();

      while ( elem != null )
      {
        if (( elem.Data.FirstName.lower.find( aText, 0 ) >= 0 ) ||
            ( elem.Data.LastName.lower.find( aText, 0 ) >= 0 ))
        {
          Device::Device.FilteredContacts.AddFirst( elem.Data );
        }
            
        elem = elem.next;
      }
    }

  }

  $rect <630,210,830,250>
  method void CancelSearch()
  {
    Device::Device.FilteredContacts.RemoveAll();


  }
}

$rect <580,220,780,260>
$output false
enum CallDirection
{
  $rect <10,10,210,50>
  item None;

  $rect <10,60,210,100>
  item Incoming;

  $rect <10,100,210,140>
  item Outgoing;
}

$rect <20,260,270,300>
$output false
class PhoneServerClass : Templates::DeviceClass
{
  $rect <440,0,640,40>
  slot askServerData
  {
    var string url;
    var string myCarID;
    var string senderNumber;
    var string message;
    var string messageContent;


    myCarID       = Device::Device.MyContact.PhoneNumber;
    senderNumber    = "";
    message        = "";
    messageContent = "";
    url            = URLpath + "receive/"+myCarID+"/"; 

    $if !$prototyper
    native ( url, senderNumber, message, messageContent )
    {
      let req = new XMLHttpRequest();
      
      req.open( "GET", url, false );
        
      req.onload = function() {
        if ( req.status == 200 ) {
          
          let json       = JSON.parse( req.response );
          senderNumber   = json.sender;
          message        = json.message;
          messageContent = json.content;
        }};
      
      req.send();
    }
    $endif
    //trace "Receive : " + " sender: " +senderNumber + " message: " + message + " content: " + messageContent;
    if ( message == "call")
    {
      Device::Device.ReceiveCall( senderNumber );
    }
    else if ( message == "answer")
    {
      Device::Device.ReceiveCallAnswered( senderNumber);
    }
    else if ( message == "reject")
    {
      Device::Device.ReceiveCallRejected( senderNumber  );
    }
    else if (( message == "endcall" ) ||
             ( message == "cancelled" ))
    {
      Device::Device.ReceiveEndCall( senderNumber );
    }
    else if ( message == "missed" )
    {
       Device::Device.ReceiveMissedCall( senderNumber );
    }
    else if ( message == "message" )
    {
       Device::Device.ReceiveMessage( senderNumber, messageContent );
    } 

  }

  $rect <30,80,230,120>
  inherited method Done()
  {
    // The following section is intended to perform de-initialization-related operations
    // in the underlying device or middleware. Consequently, the section is taken in
    // account only when generating code (not during prototyping).
    $if !$prototyper
      var object thisObject = this;

      /*
         TO DO:

         The following native statement is intended to enclose code to communicate with
         your device API. The variable 'thisObject' contains a pointer to the actually
         de-initialized Device::DeviceClass1 object. Use the 'thisObject' pointer to
         e.g. de-register the object from the middleware if you have registered it
         beforehand.
         
      */

      native ( thisObject )
      {
        /*
           TO DO:

           Depending on your application case you call functions of the underlying
           middleware (or access the device directly) in order to perform the necessary
           de-initialization steps. For example, you invoke some 'C' function:

             YourDevice_DeInitialize();

           IMPORTANT:
           ----------

           The variable 'thisObject' represents the actually de-initialized instance of the
           Device::DeviceClass1. If you have stored this object at the initialization
           time (in the 'Init' method) in some global C variable or registered it by the
           middleware, it is important to perform now the opposite operation. Set the
           global variable to NULL or de-register 'thisObject' object from the middleware.
           
        */
      }
    $endif
  }

  $rect <30,40,230,80>
  inherited method Init()
  {
    // The following section is intended to perform initialization-related operations
    // in the underlying device or middleware. Consequently, the section is taken in
    // account only when generating code (not during prototyping).
    $if !$prototyper
      var object thisObject = this;

      /*
         TO DO:

         The following native statement is intended to enclose code to communicate with
         your device API. The variable 'thisObject' contains a pointer to the actually
         initialized Device::DeviceClass1 object. Use the 'thisObject' pointer to
         e.g. register the object by the middleware as receiver of events, etc.
         
      */

      native ( thisObject )
      {
        /*
           TO DO:

           Depending on your application case you call functions of the underlying
           middleware (or access the device directly) in order to perform the necessary
           initialization steps. For example, you invoke some 'C' function:

             YourDevice_Initialize();

           The variable 'thisObject' represents the actually initialized instance of the
           Device::DeviceClass1. You can store this variable e.g. in the middleware
           and use it whenever the middleware needs to notify the GUI application about
           some state alternation or events. In this manner, the middleware will be able
           to invoke methods of the interface device object.

           For example, you can store 'thisObject' in some global C variable:

             // Declaration of the global C variable
             XObject theDeviceObject;

             // Store the instance in the global variable
             theDeviceObject = thisObject;

           Later use the global variable e.g. to provide the GUI application with events:

             ApplicationDeviceClass__TriggerSomeEvent( theDeviceObject );

           IMPORTANT:
           ----------

           If you store 'thisObject' for later use, don't forget to implement the opposite
           operation in the method 'Done'. Concrete, 'Done' should set the global variable
           again to the value NULL.

        */
      }
    $endif
  }

  // Constructor and Destructor
  note group Note1
  {
    attr Bounds = <10,0,250,140>;
  }

  $rect <250,0,450,40>
  object Core::Timer PollServerData
  {
    preset OnTrigger = askServerData;
  }

  $rect <440,40,640,80>
  method bool StartCall( arg string aReceiverNumber )
  {
    var string url;
    var string result;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendcall/call/" + senderID+"/"+aReceiverNumber; 

    $if !$prototyper
    native ( url, result )
    {
      var req = new XMLHttpRequest();
      
      req.open( "POST", url, false );
      
      req.onload = function() {
        if ( req.status == 200 ) {
            console.log( req.status );
            result = req.responseText;
        }};
        
      req.send();
    }
    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <440,80,640,120>
  method bool EndCall( arg string aReceiverNumber )
  {
    var string url;
    var string result;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendcall/cancelled/"+senderID+"/"+aReceiverNumber; 

    $if !$prototyper
    native ( url, result )
    {
      var xhr = new XMLHttpRequest();
      
      xhr.open( "POST", url, false ); 
      
      xhr.onload = function() {
        if ( req.status == 200 ) {
            console.log(req.status );
            result = req.responseText;
        }};
      
      xhr.send();
    }
    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <650,80,850,120>
  method bool RejectCall( arg string aReceiverNumber )
  {
    var string url;
    var string result;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendcall/reject/" + senderID+"/"+aReceiverNumber;

    $if !$prototyper
    native ( url, result )
    {
      var req = new XMLHttpRequest();
      
      req.open( "POST", url, false );
      
      req.onload = function() {
        if ( req.status == 200 ) {
            console.log( req.status );
            result = req.responseText;
        }};
        
      req.send();
    }
    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <640,40,840,80>
  method bool AnswerCall( arg string aReceiverNumber )
  {
    var string url;
    var string result;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendcall/answer/" + senderID +"/"+ aReceiverNumber; 

    $if !$prototyper
    native ( url, result )
    {
      var req = new XMLHttpRequest(); 
      
      req.open( "POST", url, false );
      
      req.onload = function() {
        if ( req.status == 200 ) {
            console.log( req.status );
            result = req.responseText;
        }};
        
      req.send();
    }

    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <440,120,640,160>
  method bool CancelledCall( arg string aReceiverNumber )
  {
    var string url;
    var string result;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendcall/cancelled/" + senderID+"/"+aReceiverNumber; 

    $if !$prototyper
    native ( url, result )
    {
      var req = new XMLHttpRequest();
      
      req.open( "POST", url, false );
      
      req.onload = function() {
        if ( req.status == 200 ) {
            console.log( req.status );
            result = req.responseText;
        }};
        
      req.send();
    }

    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <440,180,640,220>
  method bool SendMessage( arg string aReceiverNumber, arg string aMessage )
  {
    var string result;
    var string url;
    var string senderID;

    senderID = Device::Device.MyContact.PhoneNumber;
    url      = URLpath + "sendmessage/message/" + senderID + "/" + aReceiverNumber;

    $if !$prototyper
    native ( url, result )
    {
      var req = new XMLHttpRequest();
      
      req.open("POST", url, false);
      
      req.onload = function() {
        if ( req.status == 200 ) {
            console.log( req.status );
            result = req.responseText;
        }};
        
        req.send(aMessage);
    }
    $endif

    if ( result == "" )
      return true;
      
    return false;
  }

  $rect <40,140,240,180>
  var string URLpath = $RestApiUrl;

  // Directives to adapt the order of members belonging to this class so they appear 
  // correctly arranged relative to the members inherited from the ancestor (super) 
  // classes. The numbers indicate the order-displacement to apply on the respective 
  // member once all members have been loaded and combined with members from the 
  // ancestor classes.
  $reorder askServerData 3
}

$rect <20,300,270,340>
autoobject Device::PhoneServerClass PhoneServer;

// Device
note group Note4
{
  attr Bounds = <0,210,290,410>;
}

$rect <20,350,270,390>
$output false
class PhoneServerCallInfo
{
  $rect <0,0,200,40>
  property string Caller;

  $rect <0,40,200,80>
  onset Caller
  {
    // The value doesn't change - nothing to do.
    if ( pure Caller == value )
      return;

    // Remember the property's new value.
    pure Caller = value;

    // TO DO:
    // 
    // Now you can handle the alternation of the property.
  }

  $rect <210,0,410,40>
  property string Receiver;

  $rect <210,40,410,80>
  onset Receiver
  {
    // The value doesn't change - nothing to do.
    if ( pure Receiver == value )
      return;

    // Remember the property's new value.
    pure Receiver = value;

    // TO DO:
    // 
    // Now you can handle the alternation of the property.
  }
}

$rect <890,130,1090,170>
$output false
class Message
{
  $rect <10,20,210,60>
  var Device::Message next;

  $rect <10,170,210,210>
  property string MessageContent = "";

  $rect <210,170,410,210>
  onset MessageContent
  {
    // The value doesn't change - nothing to do.
    if ( pure MessageContent == value )
      return;

    // Remember the property's new value.
    pure MessageContent = value;

    notifyobservers this;
  }

  $rect <10,130,210,170>
  property Device::Contact Sender;

  $rect <210,130,410,170>
  onset Sender
  {
    // The value doesn't change - nothing to do.
    if ( pure Sender == value )
      return;

    // Remember the property's new value.
    pure Sender = value;

    notifyobservers this;
  }

  $rect <10,90,210,130>
  property Device::Contact Receiver;

  $rect <210,90,410,130>
  onset Receiver
  {
    // The value doesn't change - nothing to do.
    if ( pure Receiver == value )
      return;

    // Remember the property's new value.
    pure Receiver = value;

    notifyobservers this;
  }

  $rect <10,210,210,250>
  property Core::Time TimeSent;

  $rect <210,210,410,250>
  onset TimeSent
  {
    // The value doesn't change - nothing to do.
    if ( pure TimeSent == value )
      return;

    // Remember the property's new value.
    pure TimeSent = value;

    notifyobservers this;
  }

  $rect <420,210,620,250>
  method string GetTimeOfCall()
  {
    var Core::TimeSpan time = new Core::TimeSpan;
    if ( TimeSent == null )
      return "";

    time = (new Core::Time).CurrentTime.Difference( TimeSent );
    if ( time.TotalHours < 24)
      return TimeSent.Format( "%H:%M %p" );

    if ( TimeSent.Day < (new Core::Time).CurrentTime.Day)
      return TimeSent.Format( "%w" );
      
    else
      return TimeSent.Format( "%d:%m:%y" );
  }

  $rect <470,30,670,70>
  method void TraceMessage()
  {
    trace "message: " + MessageContent ;
  }

  $rect <10,250,210,290>
  property bool IsSeen = false;

  $rect <210,250,410,290>
  onset IsSeen
  {
    // The value doesn't change - nothing to do.
    if ( pure IsSeen == value )
      return;

    // Remember the property's new value.
    pure IsSeen = value;

    notifyobservers this;
  }
}

// Messages
note group Note5
{
  attr Bounds = <820,0,1130,360>;
}

$rect <860,90,1060,130>
$output false
class MessagesList
{
  $rect <0,0,200,40>
  var Device::Message head = null;

  $rect <0,90,200,130>
  method void Add( arg Device::Message aMessage )
  {
    if ( head ==  null )
    {  
      head = aMessage; 
    }  
    else
    {
      // add contact after the last node
      var Device::Message lastNode = head;
      while ( lastNode.next != null )
      {
        lastNode = lastNode.next;
      }

      lastNode.next = aMessage;
    }

    NoOfItems +=1;

  }

  $rect <0,130,200,170>
  method void Remove( arg Device::Message aMessage )
  {
    var Device::Message mes = head;
    var Device::Message prev = null;

    if (( mes != null) && ( mes == aMessage ))
    {
      head = mes.next;
      NoOfItems -= 1;
    }
     
    else
    {
      while ((mes != null) && (mes != aMessage))
      {
        prev = mes;
        mes = mes.next;
       }
       prev.next = mes.next;
       NoOfItems -= 1;
    }
  }

  $rect <200,200,400,240>
  method void TraceMessages()
  {
    var Device::Message elem = head;

    while ( elem != null )
    {
      elem.TraceMessage();
      elem = elem.next;
    }

  }

  $rect <210,0,410,40>
  property int32 NoOfItems = 0;

  $rect <210,40,410,80>
  onset NoOfItems
  {
    // The value doesn't change - nothing to do.
    if ( pure NoOfItems == value )
      return;

    // Remember the property's new value.
    pure NoOfItems = value;

    notifyobservers ^NoOfItems;

  }

  $rect <0,230,200,270>
  method Device::Message GetLastMessage()
  {
    var Device::Message msg = head;
    if ( msg != null )
    {
      while ( msg.next !=null )
      {
        msg = msg.next;
      }

    }
    return msg;
  }

  $rect <0,270,200,310>
  method Device::Message GetMessageByNr( arg int32 aIndex )
  {
    if ( head == null || aIndex >= NoOfItems )
      return null;
      
    var Device::Message message = head;
    var int32 it = 0;
    while ( it != aIndex && message != null )
    {
      message = message.next;
      it += 1;
    }

    return message;

  }

  $rect <0,170,200,210>
  method void RemoveAll()
  {
    head = null;
  }
}

$rect <860,50,1060,90>
$output false
class HistoryMessagesList : Device::ContactsList
{
  $rect <10,0,210,40>
  property int32 UnreadMessagesNr = 0;

  $rect <10,40,210,80>
  onset UnreadMessagesNr
  {
    // The value doesn't change - nothing to do.
    if ( pure UnreadMessagesNr == value )
      return;

    // Remember the property's new value.
    pure UnreadMessagesNr = value;

    notifyobservers this;
  }

  $rect <10,110,260,150>
  method void FindUnreadMessagesNr()
  {
    var Device::ContactListElement elem = head;
    var int32 nr = 0;

    while ( elem != null )
    {
      nr += elem.Data.UnreadMessagesNr;
      elem = elem.next;
    }

    if ( UnreadMessagesNr != nr )
      UnreadMessagesNr = nr;
      
  }
}