diff --git a/res/layout/activity_sflphone_home.xml b/res/layout/activity_sflphone_home.xml
index bc7d239..851d067 100644
--- a/res/layout/activity_sflphone_home.xml
+++ b/res/layout/activity_sflphone_home.xml
@@ -99,4 +99,4 @@
 <!--             android:src="@drawable/ic_incomingcall" /> -->
     </LinearLayout>
 
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/res/layout/call_element_list.xml b/res/layout/call_element_list.xml
index 015f1b4..1e80fee 100644
--- a/res/layout/call_element_list.xml
+++ b/res/layout/call_element_list.xml
@@ -37,6 +37,12 @@
 	android:paddingLeft="8dp"
 	android:paddingRight="8dp" >
 
+        <Button
+            android:id="@+id/account_selection_button"
+            android:layout_height="wrap_content"
+            android:layout_width="match_parent"
+            android:text="No Account Selected"/>
+
 	<ListView
 		android:id="@id/android:list"
 		android:layout_width="match_parent"
