internal void FetchOptEntryLevelRankFromRuntime()
 {
     if (skypeRef.logging) skypeRef.Log("Fetching P_OPT_ENTRY_LEVEL_RANK from runtime");
     skypeRef.transport.SubmitPropertyRequest(18, 906, this.OID);
     if (skypeRef.transport.PropResponseWasOk(906))
     {
     cache_opt_entry_level_rank = (SktParticipant.RANK)skypeRef.decoder.DecodeUint();
     cache[24] = true;
     }
     skypeRef.transport.ResumeSocketReaderFromPropRequest();
 }
        /** When the socket reader receives a property update from runtime, it decodes object ID
         * property ID and the new value of the property. It then calls this method of
         * the target object, to update the new value in property cache. After updating the cache,
         * this method then fires appropriate event in skype.events to notify the UI of what has happened.
         * DispatchPropertyUpdate is executed in the socket reader thread.
         */
        internal override void DispatchPropertyUpdate(uint propId, object value, bool hasValue)
        {
            switch (propId)
            {
            case 972: /* Conversation.P_IDENTITY */
                cache[0] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_identity = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_IDENTITY = " + cache_identity.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_IDENTITY - update without value");
                skypeRef.events.FireOnConversationIdentity(this, cache_identity);
                break;

            case 902: /* Conversation.P_TYPE */
                cache[1] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_type = (SktConversation.TYPE)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_TYPE = " + cache_type.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_TYPE - update without value");
                skypeRef.events.FireOnConversationType(this, cache_type);
                break;

            case 918: /* Conversation.P_LIVE_HOST */
                cache[2] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_host = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_HOST = " + cache_live_host.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_HOST - update without value");
                skypeRef.events.FireOnConversationLiveHost(this, cache_live_host);
                break;

            case 974: /* Conversation.P_LIVE_START_TIMESTAMP */
                cache[3] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_start_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_START_TIMESTAMP = " + cache_live_start_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_START_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationLiveStartTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_live_start_timestamp));
                break;

            case 996: /* Conversation.P_LIVE_IS_MUTED */
                cache[4] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_is_muted = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_IS_MUTED = " + cache_live_is_muted.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LIVE_IS_MUTED - update without value");
                skypeRef.events.FireOnConversationLiveIsMuted(this, cache_live_is_muted);
                break;

            case 920: /* Conversation.P_ALERT_STRING */
                cache[5] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_alert_string = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_ALERT_STRING = " + cache_alert_string.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_ALERT_STRING - update without value");
                skypeRef.events.FireOnConversationAlertString(this, cache_alert_string);
                break;

            case 921: /* Conversation.P_IS_BOOKMARKED */
                cache[6] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_is_bookmarked = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_IS_BOOKMARKED = " + cache_is_bookmarked.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_IS_BOOKMARKED - update without value");
                skypeRef.events.FireOnConversationIsBookmarked(this, cache_is_bookmarked);
                break;

            case 925: /* Conversation.P_GIVEN_DISPLAYNAME */
                cache[7] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_given_displayname = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_GIVEN_DISPLAYNAME = " + cache_given_displayname.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_GIVEN_DISPLAYNAME - update without value");
                skypeRef.events.FireOnConversationGivenDisplayname(this, cache_given_displayname);
                break;

            case 924: /* Conversation.P_DISPLAYNAME */
                cache[8] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_displayname = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_DISPLAYNAME = " + cache_displayname.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_DISPLAYNAME - update without value");
                skypeRef.events.FireOnConversationDisplayname(this, cache_displayname);
                break;

            case 927: /* Conversation.P_LOCAL_LIVESTATUS */
                cache[9] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_local_livestatus = (SktConversation.LOCAL_LIVESTATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LOCAL_LIVESTATUS = " + cache_local_livestatus.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LOCAL_LIVESTATUS - update without value");
                skypeRef.events.FireOnConversationLocalLivestatus(this, cache_local_livestatus);
                break;

            case 928: /* Conversation.P_INBOX_TIMESTAMP */
                cache[10] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_inbox_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_TIMESTAMP = " + cache_inbox_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationInboxTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_inbox_timestamp));
                break;

            case 973: /* Conversation.P_INBOX_MESSAGE_ID */
                cache[11] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_inbox_message_id = (SktMessage)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_MESSAGE_ID = " + cache_inbox_message_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_INBOX_MESSAGE_ID - update without value");
                skypeRef.events.FireOnConversationInboxMessageId(this, cache_inbox_message_id);
                break;

            case 975: /* Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES */
                cache[12] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_suppressed_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES = " + cache_unconsumed_suppressed_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_SUPPRESSED_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedSuppressedMessages(this, cache_unconsumed_suppressed_messages);
                break;

            case 976: /* Conversation.P_UNCONSUMED_NORMAL_MESSAGES */
                cache[13] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_normal_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_NORMAL_MESSAGES = " + cache_unconsumed_normal_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_NORMAL_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedNormalMessages(this, cache_unconsumed_normal_messages);
                break;

            case 977: /* Conversation.P_UNCONSUMED_ELEVATED_MESSAGES */
                cache[14] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_elevated_messages = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_ELEVATED_MESSAGES = " + cache_unconsumed_elevated_messages.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_ELEVATED_MESSAGES - update without value");
                skypeRef.events.FireOnConversationUnconsumedElevatedMessages(this, cache_unconsumed_elevated_messages);
                break;

            case 970: /* Conversation.P_UNCONSUMED_MESSAGES_VOICE */
                cache[15] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_unconsumed_messages_voice = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_MESSAGES_VOICE = " + cache_unconsumed_messages_voice.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_UNCONSUMED_MESSAGES_VOICE - update without value");
                skypeRef.events.FireOnConversationUnconsumedMessagesVoice(this, cache_unconsumed_messages_voice);
                break;

            case 971: /* Conversation.P_ACTIVE_VM_ID */
                cache[16] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_active_vm_id = (SktVoicemail)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_ACTIVE_VM_ID = " + cache_active_vm_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_ACTIVE_VM_ID - update without value");
                skypeRef.events.FireOnConversationActiveVmId(this, cache_active_vm_id);
                break;

            case 979: /* Conversation.P_CONSUMPTION_HORIZON */
                cache[17] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_consumption_horizon = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CONSUMPTION_HORIZON = " + cache_consumption_horizon.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CONSUMPTION_HORIZON - update without value");
                skypeRef.events.FireOnConversationConsumptionHorizon(this, skypeRef.UnixTimestampToDateTime(cache_consumption_horizon));
                break;

            case 981: /* Conversation.P_LAST_ACTIVITY_TIMESTAMP */
                cache[18] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_last_activity_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_LAST_ACTIVITY_TIMESTAMP = " + cache_last_activity_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_LAST_ACTIVITY_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationLastActivityTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_last_activity_timestamp));
                break;

            case 915: /* Conversation.P_SPAWNED_FROM_CONVO_ID */
                cache[19] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_spawned_from_convo_id = (SktConversation)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_SPAWNED_FROM_CONVO_ID = " + cache_spawned_from_convo_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_SPAWNED_FROM_CONVO_ID - update without value");
                skypeRef.events.FireOnConversationSpawnedFromConvoId(this, cache_spawned_from_convo_id);
                break;

            case 903: /* Conversation.P_CREATOR */
                cache[20] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_creator = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATOR = " + cache_creator.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATOR - update without value");
                skypeRef.events.FireOnConversationCreator(this, cache_creator);
                break;

            case 904: /* Conversation.P_CREATION_TIMESTAMP */
                cache[21] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_creation_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATION_TIMESTAMP = " + cache_creation_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_CREATION_TIMESTAMP - update without value");
                skypeRef.events.FireOnConversationCreationTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_creation_timestamp));
                break;

            case 919: /* Conversation.P_MY_STATUS */
                cache[22] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_my_status = (SktConversation.MY_STATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_MY_STATUS = " + cache_my_status.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_MY_STATUS - update without value");
                skypeRef.events.FireOnConversationMyStatus(this, cache_my_status);
                break;

            case 922: /* Conversation.P_OPT_JOINING_ENABLED */
                cache[23] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_joining_enabled = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_JOINING_ENABLED = " + cache_opt_joining_enabled.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_JOINING_ENABLED - update without value");
                skypeRef.events.FireOnConversationOptJoiningEnabled(this, cache_opt_joining_enabled);
                break;

            case 906: /* Conversation.P_OPT_ENTRY_LEVEL_RANK */
                cache[24] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_entry_level_rank = (SktParticipant.RANK)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ENTRY_LEVEL_RANK = " + cache_opt_entry_level_rank.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ENTRY_LEVEL_RANK - update without value");
                skypeRef.events.FireOnConversationOptEntryLevelRank(this, cache_opt_entry_level_rank);
                break;

            case 907: /* Conversation.P_OPT_DISCLOSE_HISTORY */
                cache[25] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_disclose_history = (Boolean)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_DISCLOSE_HISTORY = " + cache_opt_disclose_history.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_DISCLOSE_HISTORY - update without value");
                skypeRef.events.FireOnConversationOptDiscloseHistory(this, cache_opt_disclose_history);
                break;

            case 909: /* Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES */
                cache[26] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_opt_admin_only_activities = (SktConversation.ALLOWED_ACTIVITY)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES = " + cache_opt_admin_only_activities.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_OPT_ADMIN_ONLY_ACTIVITIES - update without value");
                skypeRef.events.FireOnConversationOptAdminOnlyActivities(this, cache_opt_admin_only_activities);
                break;

            case 980: /* Conversation.P_PASSWORDHINT */
                cache[27] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_passwordhint = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_PASSWORDHINT = " + cache_passwordhint.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_PASSWORDHINT - update without value");
                skypeRef.events.FireOnConversationPasswordhint(this, cache_passwordhint);
                break;

            case 910: /* Conversation.P_META_NAME */
                cache[28] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_name = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_NAME = " + cache_meta_name.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_NAME - update without value");
                skypeRef.events.FireOnConversationMetaName(this, cache_meta_name);
                break;

            case 911: /* Conversation.P_META_TOPIC */
                cache[29] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_topic = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_TOPIC = " + cache_meta_topic.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_TOPIC - update without value");
                skypeRef.events.FireOnConversationMetaTopic(this, cache_meta_topic);
                break;

            case 913: /* Conversation.P_META_GUIDELINES */
                cache[30] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_guidelines = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_GUIDELINES = " + cache_meta_guidelines.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_GUIDELINES - update without value");
                skypeRef.events.FireOnConversationMetaGuidelines(this, cache_meta_guidelines);
                break;

            case 914: /* Conversation.P_META_PICTURE */
                cache[31] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_meta_picture = (byte[])value;
                    if (skypeRef.logging) skypeRef.Log("Conversation.P_META_PICTURE = binary size " + cache_meta_picture.Length.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Conversation.P_META_PICTURE - update without value");
                skypeRef.events.FireOnConversationMetaPicture(this, cache_meta_picture);
                break;

            default:
                skypeRef.Error(String.Format("Invalid Conversation class property ID ({0})received from socket.", propId)); break;
            }
        }
 internal void FetchRequestedRankFromRuntime()
 {
     if (skypeRef.logging) skypeRef.Log("Fetching P_REQUESTED_RANK from runtime");
     skypeRef.transport.SubmitPropertyRequest(19, 933, this.OID);
     if (skypeRef.transport.PropResponseWasOk(933))
     {
     cache_requested_rank = (SktParticipant.RANK)skypeRef.decoder.DecodeUint();
     cache[3] = true;
     }
     skypeRef.transport.ResumeSocketReaderFromPropRequest();
 }
        /** When the socket reader receives a property update from runtime, it decodes object ID
         * property ID and the new value of the property. It then calls this method of
         * the target object, to update the new value in property cache. After updating the cache,
         * this method then fires appropriate event in skype.events to notify the UI of what has happened.
         * DispatchPropertyUpdate is executed in the socket reader thread.
         */
        internal override void DispatchPropertyUpdate(uint propId, object value, bool hasValue)
        {
            switch (propId)
            {
            case 930: /* Participant.P_CONVO_ID */
                cache[0] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_convo_id = (SktConversation)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_CONVO_ID = " + cache_convo_id.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_CONVO_ID - update without value");
                skypeRef.events.FireOnParticipantConvoId(this, cache_convo_id);
                break;

            case 931: /* Participant.P_IDENTITY */
                cache[1] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_identity = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_IDENTITY = " + cache_identity.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_IDENTITY - update without value");
                skypeRef.events.FireOnParticipantIdentity(this, cache_identity);
                break;

            case 932: /* Participant.P_RANK */
                cache[2] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_rank = (SktParticipant.RANK)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_RANK = " + cache_rank.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_RANK - update without value");
                skypeRef.events.FireOnParticipantRank(this, cache_rank);
                break;

            case 933: /* Participant.P_REQUESTED_RANK */
                cache[3] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_requested_rank = (SktParticipant.RANK)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_REQUESTED_RANK = " + cache_requested_rank.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_REQUESTED_RANK - update without value");
                skypeRef.events.FireOnParticipantRequestedRank(this, cache_requested_rank);
                break;

            case 934: /* Participant.P_TEXT_STATUS */
                cache[4] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_text_status = (SktParticipant.TEXT_STATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_TEXT_STATUS = " + cache_text_status.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_TEXT_STATUS - update without value");
                skypeRef.events.FireOnParticipantTextStatus(this, cache_text_status);
                break;

            case 935: /* Participant.P_VOICE_STATUS */
                cache[5] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_voice_status = (SktParticipant.VOICE_STATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_VOICE_STATUS = " + cache_voice_status.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_VOICE_STATUS - update without value");
                skypeRef.events.FireOnParticipantVoiceStatus(this, cache_voice_status);
                break;

            case 936: /* Participant.P_VIDEO_STATUS */
                cache[6] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_video_status = (SktParticipant.VIDEO_STATUS)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_VIDEO_STATUS = " + cache_video_status.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_VIDEO_STATUS - update without value");
                skypeRef.events.FireOnParticipantVideoStatus(this, cache_video_status);
                break;

            case 943: /* Participant.P_LIVE_IDENTITY */
                cache[7] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_identity = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_IDENTITY = " + cache_live_identity.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_IDENTITY - update without value");
                skypeRef.events.FireOnParticipantLiveIdentity(this, cache_live_identity);
                break;

            case 938: /* Participant.P_LIVE_PRICE_FOR_ME */
                cache[8] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_price_for_me = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_PRICE_FOR_ME = " + cache_live_price_for_me.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_PRICE_FOR_ME - update without value");
                skypeRef.events.FireOnParticipantLivePriceForMe(this, cache_live_price_for_me);
                break;

            case 948: /* Participant.P_LIVE_FWD_IDENTITIES */
                cache[9] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_fwd_identities = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_FWD_IDENTITIES = " + cache_live_fwd_identities.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_FWD_IDENTITIES - update without value");
                skypeRef.events.FireOnParticipantLiveFwdIdentities(this, cache_live_fwd_identities);
                break;

            case 939: /* Participant.P_LIVE_START_TIMESTAMP */
                cache[10] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_start_timestamp = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_START_TIMESTAMP = " + cache_live_start_timestamp.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_START_TIMESTAMP - update without value");
                skypeRef.events.FireOnParticipantLiveStartTimestamp(this, skypeRef.UnixTimestampToDateTime(cache_live_start_timestamp));
                break;

            case 941: /* Participant.P_SOUND_LEVEL */
                cache[11] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_sound_level = (uint)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_SOUND_LEVEL = " + cache_sound_level.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_SOUND_LEVEL - update without value");
                skypeRef.events.FireOnParticipantSoundLevel(this, cache_sound_level);
                break;

            case 942: /* Participant.P_DEBUGINFO */
                cache[12] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_debuginfo = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_DEBUGINFO = " + cache_debuginfo.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_DEBUGINFO - update without value");
                skypeRef.events.FireOnParticipantDebuginfo(this, cache_debuginfo);
                break;

            case 947: /* Participant.P_LAST_VOICE_ERROR */
                cache[13] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_last_voice_error = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LAST_VOICE_ERROR = " + cache_last_voice_error.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LAST_VOICE_ERROR - update without value");
                skypeRef.events.FireOnParticipantLastVoiceError(this, cache_last_voice_error);
                break;

            case 949: /* Participant.P_QUALITY_PROBLEMS */
                cache[14] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_quality_problems = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_QUALITY_PROBLEMS = " + cache_quality_problems.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_QUALITY_PROBLEMS - update without value");
                skypeRef.events.FireOnParticipantQualityProblems(this, cache_quality_problems);
                break;

            case 950: /* Participant.P_LIVE_TYPE */
                cache[15] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_type = (SktSkype.IDENTITYTYPE)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_TYPE = " + cache_live_type.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_TYPE - update without value");
                skypeRef.events.FireOnParticipantLiveType(this, cache_live_type);
                break;

            case 951: /* Participant.P_LIVE_COUNTRY */
                cache[16] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_live_country = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_COUNTRY = " + cache_live_country.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LIVE_COUNTRY - update without value");
                skypeRef.events.FireOnParticipantLiveCountry(this, cache_live_country);
                break;

            case 952: /* Participant.P_TRANSFERRED_BY */
                cache[17] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_transferred_by = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_TRANSFERRED_BY = " + cache_transferred_by.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_TRANSFERRED_BY - update without value");
                skypeRef.events.FireOnParticipantTransferredBy(this, cache_transferred_by);
                break;

            case 953: /* Participant.P_TRANSFERRED_TO */
                cache[18] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_transferred_to = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_TRANSFERRED_TO = " + cache_transferred_to.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_TRANSFERRED_TO - update without value");
                skypeRef.events.FireOnParticipantTransferredTo(this, cache_transferred_to);
                break;

            case 954: /* Participant.P_ADDER */
                cache[19] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_adder = (String)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_ADDER = " + cache_adder.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_ADDER - update without value");
                skypeRef.events.FireOnParticipantAdder(this, cache_adder);
                break;

            case 955: /* Participant.P_LAST_LEAVEREASON */
                cache[20] = hasValue; // if no value - invalidate cache
                if (hasValue)
                {
                    cache_last_leavereason = (SktSkype.LEAVE_REASON)value;
                    if (skypeRef.logging) skypeRef.Log("Participant.P_LAST_LEAVEREASON = " + cache_last_leavereason.ToString());
                }
                else if (skypeRef.logging) skypeRef.Log("Participant.P_LAST_LEAVEREASON - update without value");
                skypeRef.events.FireOnParticipantLastLeavereason(this, cache_last_leavereason);
                break;

            default:
                skypeRef.Error(String.Format("Invalid Participant class property ID ({0})received from socket.", propId)); break;
            }
        }
 public OnParticipantRequestedRankArgs(SktParticipant sender, SktParticipant.RANK newValue)
 {
     this.sender = sender;  value = newValue;
 }
 public OnConversationOptEntryLevelRankArgs(SktConversation sender, SktParticipant.RANK newValue)
 {
     this.sender = sender;  value = newValue;
 }