<?xml version="1.0" encoding="UTF-8" ?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
    	  
  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
  
-->
<library>

<class name="contactsListItem" extends="basePagingListItem" showhandcursor="false" height="40">
	
	<attribute name="username" value="" type="string" />
	<attribute name="shareCalendar" value="false" type="boolean" />
	<attribute name="searchUserProfileImage" value="null" />
	
	<handler name="onmouseover">
		<![CDATA[
			if (this.searchUserProfileImage != null) {
				this.searchUserProfileImage.destroy();
				this.searchUserProfileImage = null;
			}
			
			if (this.refObj != null) {
				this.searchUserProfileImage = new lz.searchUserProfileImage(canvas,{
						x:this.getAttributeRelative("x",canvas) - 120,
						y:this.getAttributeRelative("y",canvas) - 30,
						profileUrl: canvas.getPictureUrl(this.refObj.pictureuri
							, '&moduleName=remoteuserprofile&remoteUserid='+this.refObj.user_id)
					});
			}
		]]>
	</handler>
	
	<handler name="onmouseout">
		if (this.searchUserProfileImage != null) {
			this.searchUserProfileImage.destroy();
			this.searchUserProfileImage = null;
		}
	</handler>
	
	<turnOverTextItem name="_username" width="200" multiline="true"
					  text="${ parent.username }" />
					  
					  <!--
	<turnOverTextItem name="_timezone" width="80" multiline="true"
					  text="${ parent.timezone }" />
	<turnOverTextItem name="_searchOffers" width="300" multiline="true"
					  text="${ parent.searchOffers }" />
	<turnOverTextItem name="_searchSearchs" width="300" multiline="true"
					  text="${ parent.searchSearchs }" />
					   -->
	
	<view name="_icons" >
		
		<view visible="${ parent.parent.clickable }">
			
			<miniIcons name="message" y="1" x="1" resource="private_message_add_rsc" width="18" height="18" 
	               showhandcursor="true">
		        <handler name="onclick">
		            if ($debug) Debug.write("Start Conference ",parent.parent.parent.refObj.user_id);
		            parent.parent.parent.parent.parent.parent.parent.addMessage(parent.parent.parent.refObj);
		        </handler>
		        <labelTooltip labelid="1253" />
		    </miniIcons> 
			
		    <miniIcons name="profile" y="1" x="20" resource="user_profile_rsc" width="18" height="18" 
	               showhandcursor="true">
		        <handler name="onclick">
		            if ($debug) Debug.write("Start Conference ",parent.parent.parent.refObj.user_id);
		            new lz.viewUserProfileWindow(canvas,{
				            	userId:parent.parent.parent.refObj.user_id
				            });
		        </handler>
		        <labelTooltip labelid="1236" />
		    </miniIcons> 
		    
		    <!--
		     setCalendarSharing
		     -->
		    <miniIcons name="shareCalendar" y="1" x="40" resource="user_contact_calendar_add_rsc" width="18" height="18" 
                   visibility="${ (parent.parent.parent.shareCalendar) ? 'hidden' : 'visible' }" showhandcursor="true">
                <handler name="onclick">
                    if ($debug) Debug.write("Do Share ");
                    parent.parent.parent.parent.parent.parent.parent.setCalendarSharing(parent.parent.parent.refObj.userContactId, true);
                </handler>
                <labelTooltip labelid="1274" />
            </miniIcons> 
            
            <miniIcons name="unShareCalendar" y="1" x="40" resource="user_contact_calendar_delete_rsc" width="18" height="18" 
                   visibility="${ (parent.parent.parent.shareCalendar) ? 'visible' : 'hidden' }" showhandcursor="true">
                <handler name="onclick">
                    if ($debug) Debug.write("Do Not Share ");
                    parent.parent.parent.parent.parent.parent.parent.setCalendarSharing(parent.parent.parent.refObj.userContactId, false);
                </handler>
                <labelTooltip labelid="1275" />
            </miniIcons> 
		    
		    <miniIconsImage src="$once{ canvas.getThemeImage('button_cancel_rsc') }" 
		    			name="deny" y="1" x="60" width="18" height="18" showhandcursor="true">
				<handler name="onclick">
					new lz.confirmationSingle(canvas.main_content._content.inner,{
                                           labelid:1233,labeliderror:1232,
                                           refObj:this,showCheckBox:false});
            
		        </handler>
		        
		        <method name="sendConfirmation" args="yesno" >
		            parent.parent.parent.parent.parent.parent.parent.removeContactUserMethod(parent.parent.parent.refObj.userContactId);
		        </method>
		            
		        <labelTooltip labelid="1234" />
		    </miniIconsImage>
		    
	    </view>
		
		<view height="$once{ parent.parent.height }" width="1" 
        	align="right" bgcolor="black" />
	</view>
	
</class>

</library>
