AQAB777Kbs/ziV1PpA5thQ1k12pXQ3I2g042iR+cW6d7fDA0oJHoyZNx6wFTr/F++bX+02Py89x1OmVzSSWWiY33uZ08XLwUPhIrG4s0gtmaKAYF87hzynRU75a8SFaKpydU/qqOvqaFJzzE76OzftTPDrT+ItTy/AsJXYOysI/Y0dby2IA=<?xml version="1.0" encoding="utf-8" ?> 
<AppDef>
<!-- A note on reusing connection points and lines across different templates:
	Connection Points will be reused if at least one of the end-icons overlap and the cp is located at exactly the same coordinates
	Lines will be reused if they connect exactly the same icons and connection points -->
	
<!--A note on loading resources and defining the 'Source' attribute in ImageItem for SuperNavNode
loading from RESOURCE:      source="dllname.dll:resourceidentifierstring"
loading from FILE:              source="components\homepage\filename.bmp"
Images for the B-level commands are the same as images for their respective Super Commands
-->
	
	<!-- IconStyle: Contains drawing attributes for an icon
	This would be referenced by icons later. -->
	<IconStyle ID="GENERAL_ICON">
		<!-- Margins around a regular icon -->
		<MarginTop>2</MarginTop>
		<MarginLeft>3</MarginLeft>
		<MarginRight>1</MarginRight>
		<IconMarginBottom>2</IconMarginBottom>	<!-- Down Margin (between label and line) -->
		<LabelMarginBottom>1</LabelMarginBottom> <!-- Margin between icon image and label -->
		
		<!-- Margin between the main icon and the dropdown icon for supercommand -->
		<MarginDropdown>3</MarginDropdown>
		<LabelColor>#48788D</LabelColor>
		<LabelColorRollover>#48788D</LabelColorRollover>
		<IconColorRollover>#FFFFFF</IconColorRollover> 
		<RolloverRadiusHorz>34</RolloverRadiusHorz>
		<RolloverRadiusVert>26</RolloverRadiusVert>
		
		<!-- Rollover radius for supercommands which used to include the dropdown arrow icon 
			but has gone back to the same size as a normal icon rollover radius -->
		<SuperRolloverRadiusHorz>34</SuperRolloverRadiusHorz>
		<SuperRolloverRadiusVert>26</SuperRolloverRadiusVert> 
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_DROPDOWN"/>
	</IconStyle>
	
	<!-- Business Logic: Dark line conveys a flow of required steps in QuickBooks-->
	<LineStyle ID="DarkLine">
		<Color>#357E9E</Color>
		<Width>1</Width>
		<ArrowUp Type="Icon" Source="qbdomain.dll:IDI_DARK_ARROW_UP"/>
		<ArrowDown Type="Icon" Source="qbdomain.dll:IDI_DARK_ARROW_DOWN"/>
		<ArrowLeft Type="Icon" Source="qbdomain.dll:IDI_DARK_ARROW_LEFT"/>
		<ArrowRight Type="Icon" Source="qbdomain.dll:IDI_DARK_ARROW_RIGHT"/>
	</LineStyle>
	
	<!-- Business Logic: A light line conveys a flow of optional steps in QuickBooks -->
	<LineStyle ID="LightLine">
		<Color>#9AC8DC</Color>
		<Width>1</Width>
		<ArrowUp Type="Icon" Source="qbdomain.dll:IDI_LIGHT_ARROW_UP"/>
		<ArrowDown Type="Icon" Source="qbdomain.dll:IDI_LIGHT_ARROW_DOWN"/>
		<ArrowLeft Type="Icon" Source="qbdomain.dll:IDI_LIGHT_ARROW_LEFT"/>
		<ArrowRight Type="Icon" Source="qbdomain.dll:IDI_LIGHT_ARROW_RIGHT"/>
	</LineStyle>

	<!--A node in the domain layout - either icon or connection point
	Visible = always true
	Enabled: Would contain logic for checking ACE expressions. 
			 Business Logic: The SuperNav uses a subtractive model to determine 
			 if a particular command should be turned on or off.  
			 The current SKU/Flavor first determines the full set of commands available.  
			 These are then subtracted from based on the users choices at setup and in preferences 
	Description: tooltip text
	CommandID: qbCommand
	Name = would use Dictionary, text that appears on icon label
	Reminders (Future addition here): Can contain one or more reminders it is associated with
	Superclass: AccessPointItem
	Type: Can be of type Icon or Connection Point
	-->
	
	<!--Business Logic: Regular commands are represented in the SuperNav as icons defined below as SuperNavNode of type Icon.
		Rolling over the icon or the text highlights the entire element as a button 
		Clicking a regular command goes to the corresponding feature in QuickBooks -->

	<!--Nodes that are part of supplier Domain-->
	<SuperNavNode ID="SN_PURCHASE_ORDERS" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%PurchaseOrdersTooltip%" CommandID="qbw:purchord" Name="Purchase&#xD;Orders">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PURCHASE_ORDERS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_ENTER_BILLS" Type="Icon" Visible="true" Enabled="Inventory='1' OR Preferences.UseAP='1'" Description="%EnterBillsTooltip%" CommandID="qbw:bill" Name="%EnterBills%"> 
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_BILLS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_BILLS_AGAINST_INVENTORY" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%EnterBillsAgainstInventoryTooltip%" CommandID="qbw:bill_for_itemreceipts" Name="Enter Bills&#xD;Against&#xD;Inventory">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_ENTERBILLS_AGAINST_INVENTORY"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

 <!-- ifdef INTL_AU_RCTI if you disable the RCTI flag comment this out-->
  <!--SuperNavNode ID="SN_RCTI" Type="Icon" Visible="true" Enabled="Features.UK_AUBasicFeatureRemoval!='enabled'" Description="%EnterBillsAgainstInventoryTooltip%" CommandID="qbw:rcti" Name="RCTI">
    <ImageItem Type="Icon" Source="qbwin32.dll:ICON_RCTI"/>
    <IconStyleRef REFID="GENERAL_ICON" />
  </SuperNavNode-->
<!--endif-->
  <SuperNavNode ID="SN_RECEIVE_WITH_BILL" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%ReceiveWithBillTooltip%" CommandID="qbw:bill_items_tab" Name="Receive Inventory with Bill">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_RECEIVE_INVENTORY"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_RECEIVE_WITHOUT_BILL" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%ReceiveWithoutBillTooltip%" CommandID="qbw:itemreceipt" Name="Receive Inventory without Bill">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_RECEIVE_INVENTORY"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- This contains RelatedActivitiesMenu since this is a SuperCommand.
	Business Logic: Supercommands collect multiple closely related commands into one branching icon.  
	There is a visual indication that an icon branches to a menu - a dropdown arrow to the right, defined in IconStyle above.
	Clicking the super command reveals a menu of choices populated from RelatedActivitiesMenu.
    Clicking on any of these menu choices goes to the corresponding feature. -->
	<SuperNavNode ID="SN_RECEIVE_SUPERCOMMAND" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%ReceiveSuperCommandTooltip%" CommandID="qbw:SuperNavNonExecuteCommand" Name="Receive&#xD;Inventory">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_RECEIVE_INVENTORY"/>
		<IconStyleRef REFID="GENERAL_ICON" />
		<RelatedActivitiesMenu ID="RECEIVE_ITEM_B_LEVEL">
			<SuperNavNodeRef REFID="SN_RECEIVE_WITH_BILL"/>
			<SuperNavNodeRef REFID="SN_RECEIVE_WITHOUT_BILL"/>
		</RelatedActivitiesMenu>
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_PAYBILLS" Type="Icon" Visible="true" Enabled="Inventory='1' OR Preferences.UseAP='1'" Description="%PayBillsTooltip%" CommandID="qbw:paybills" Name="Pay Bills">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAY_BILLS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

<!-- ifdef INTL_AU -->
  <SuperNavNode ID="SN_SALES_TAX_MANAGER" Type="Icon" Visible="true" Enabled="SalesTax='1'" Description="%SalesTaxManagerTooltip%" CommandID="qbw:sales_tax_manager" Name="Manage&#xD;Tax">
<!-- else -->
<!--  <SuperNavNode ID="SN_SALES_TAX_MANAGER" Type="Icon" Visible="true" Enabled="SalesTax='1'" Description="%SalesTaxManagerTooltip%" CommandID="qbw:sales_tax_manager" Name="Manage&#xD;Sales&#xD;Tax"> -->
<!-- endif -->
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_SALES_TAX"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	<!--End of Nodes that are part of  supplier Domain-->
	
	
	<!-- Nodes that are part of CUSTOMER DOMAIN -->
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_ESTIMATES" Type="Icon" Visible="true" Enabled="Estimating='1'" Description="%EstimatesTooltip%" CommandID="qbw:estimate" Name="%Estimates%"> 
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_ESTIMATE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_SALESORDER" Type="Icon" Visible="true" Enabled="Features.SOT_SalesOrderTracking='enabled' AND SalesOrders='1'" Description="%SalesOrdersTooltip%" CommandID="qbw:salesorder" Name="Sales&#xD;Orders">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_SALES_ORDER"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_SALESRECEIPT" Type="Icon" Visible="true" Enabled="Preferences.UseSalesReceipts='1'" Description="%SalesReceiptTooltip%" CommandID="qbw:cashsale" Name="%SalesReceipts%">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_CCS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_INVOICE" Type="Icon" Visible="true" Enabled="Preferences.UseInvoices='1'" Description="%InvoicesTooltip%" CommandID="qbw:invoice" Name="%Invoices%">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_INVOICE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_FINANCE_CHARGE" Type="Icon" Visible="true" Enabled="FinanceCharge.HasFinanceChargeItem='1'" Description="%FinanceChargeTooltip%" CommandID="qbw:finance_charges" Name="Finance&#xD;Charges">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_FINANCE_CHARGES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_STATEMENTS" Type="Icon" Visible="true" Enabled="Preferences.UseCreateStatements='1'" Description="%StatementsTooltip%" CommandID="qbw:statements" Name="Statements">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_STATEMENTS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_STATEMENT_CHARGES" Type="Icon" Visible="true" Enabled="Preferences.UseCreateStatements='1'" Description="%StatementsChargesTooltip%" CommandID="qbw:statement_charges" Name="Statement&#xD;Charges">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_STATEMENT_CHARGES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_RECPAYMENT" Type="Icon" Visible="true" Enabled="true" Description="%ReceivePaymentsTooltip%" CommandID="qbw:recvpmts" Name="Receive&#xD;Payments">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_RECP"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
  
  <!-- ifdef INTL_AU //asb -->
  <SuperNavNode ID="SN_REFUNDS" Type="Icon" Visible="true" Enabled="true" Description="%RefundsTooltip%" CommandID="qbw:creditmemo" Name="Refunds&#xD;&amp; Adjustments"> 
    <!-- else -->
 <!--  <SuperNavNode ID="SN_REFUNDS" Type="Icon" Visible="true" Enabled="true" Description="%RefundsTooltip%" CommandID="qbw:creditmemo" Name="Refunds&#xD;&amp; Ajustments"> -->  
    <!-- endif -->    
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_REFUNDS_CREDITS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_BILLING_SOLUTIONS"  Type="Icon" Visible="true" Enabled="BillingSolutions.OnlinePaymentEnabled='1'" Description="%BillingSolutionsTooltip%" CommandID="qbw:download_bs_pmts" Name="Billing Solutions">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_GET_PAYMENTS_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_VIRTUAL_TERMINAL"  Type="Icon" Visible="true" Enabled="CreditCardPayments.UserHasMAS='1'" 
	Description="%VirtualTerminalTooltip%" CommandID="qbw:download_virtual_terminal_pmts" Name="Virtual Terminal Plus">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_GET_PAYMENTS_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_AUTOMATIC_CC_BILLING" Type="Icon" Visible="true" Enabled="CreditCardPayments.UserHasMAS='1'" 
	Description="%AutomaticCCBillingTooltip%" CommandID="qbw:download_accb_pmts" Name="Automatic Credit Card Billing">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_GET_PAYMENTS_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_TERMINAL_DOWNLOAD" Type="Icon" Visible="true" Enabled="CreditCardPayments.UserHasTerminalDownload='1'" 
	Description="%TerminalDownloadTooltip%" CommandID="qbw:terminal_download_pmts" Name="Terminal Download">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_GET_PAYMENTS_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- This contains RelatedActivitiesMenu since this is a SuperCommand.
	Business Logic: Supercommands collect multiple closely related commands into one branching icon.  
	There is a visual indication that an icon branches to a menu - a dropdown arrow to the right, defined in IconStyle above.
	Clicking the super command reveals a menu of choices populated from RelatedActivitiesMenu.
    Clicking on any of these menu choices goes to the corresponding feature. -->
        <!-- 
          john_hodgkinson, 12/8/06.  Fix for QBW045575: (Get Online Payments pop-up on Supernav should be updated).
          We used to present a b-level dropdown, now we use the same popup as on the individual
          QBMS-enabled forms (Receive Payment and friends).
        -->
  <!-- INTL_AU ShiY-->
	<!-- SuperNavNode ID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND" Type="Icon" Visible="true" Enabled="true" Description="%GetOnlinePaymentsSuperCommandTooltip%" CommandID="qbw:getonlinepayments" Name="Get Online&#xD;Payments">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_GET_PAYMENTS_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode -->
  <!-- End INTL_AU-->
	<!--End Of Nodes that are part of Customer Domain-->
	
	
	<!--Nodes that are part of Employees Domain-->

  <!-- ifdef INTL_AU -->
	<SuperNavNode ID="SN_PAYROLL_CENTER" Type="Icon" Visible="true" 
	Enabled="(Features.NZLocalised='enabled' OR Payroll.Assisted='1' OR (Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1')) AND PROutsourced='0' AND Payroll.IsOneTimeDownload='0'" Description="%PayrollCenterTooltip%" CommandID="qbw:employee_domain" CommandArgs="context=Dashboard" Name="Payroll&#xD;Centre">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAYROLL_CENTER"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
  <!-- else -->
  <!-- <SuperNavNode ID="SN_PAYROLL_CENTER" Type="Icon" Visible="true" -->
	<!-- Enabled="(Payroll.Assisted='1' OR (Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1')) AND PROutsourced='0' AND Payroll.IsOneTimeDownload='0'" Description="%PayrollCenterTooltip%" CommandID="qbw:employee_domain" CommandArgs="context=Dashboard" Name="Payroll&#xD;Center">
    <ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAYROLL_CENTER"/>
    <IconStyleRef REFID="GENERAL_ICON" />
  </SuperNavNode> -->
  <!-- endif -->
	
	<SuperNavNode ID="SN_PAY_EMPLOYEES" Type="Icon" Visible="true" 
	Enabled="Payroll.AllowManualCalc='1' OR Payroll.Assisted='1' OR ((Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1') AND PROutsourced='0')" Description="%PayEmployeesTooltip%" CommandID="qbw:supernav_pay_employees" Name="Pay&#xD;Employees">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAY_EMPLOYEES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_PAY_LIABILITIES" Type="Icon" Visible="true" Enabled="Payroll.AllowManualCalc='1' OR Payroll.Assisted='1' OR ((Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1') AND PROutsourced='0')" 
	Description="%PayLiabilitiesTooltip%" CommandID="qbw:supernav_pay_liabilities" Name="Pay&#xD;Liabilities">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAY_LIABILITIES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
  <!-- QBPP011396: Vaidy 10-9-06 -->
  <!-- Added check for GenericBasic, since StandardOrEnhanced misleadingly checks for the Basic subtypes as well -->
  <!-- Also, removed the Payroll.AssistedActive='0' check since it makes no sense -->
	<SuperNavNode ID="SN_PROCESS_PAYROLL_FORMS" Type="Icon" Visible="true" Enabled="((Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1') AND Payroll.GenericBasic='0' AND PROutsourced='0')" 
	Description="%ProcessPayrollFormsTooltip%" CommandID="qbw:process_pay_forms" Name="Process&#xD;Payment&#xD;Summaries">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PROCESS_PAYROLL_FORMS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
  <!-- else -->
  <!-- <SuperNavNode ID="SN_PROCESS_PAYROLL_FORMS" Type="Icon" Visible="true" Enabled="((Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1') AND Payroll.GenericBasic='0' AND PROutsourced='0')" 
	Description="%ProcessPayrollFormsTooltip%" CommandID="qbw:process_pay_forms" Name="Process&#xD;Payroll&#xD;Forms">
    <ImageItem Type="Icon" Source="qbwin32.dll:ICON_PROCESS_PAYROLL_FORMS"/>
    <IconStyleRef REFID="GENERAL_ICON" />
  </SuperNavNode> -->
  <!-- endif -->
	
	<SuperNavNode ID="SN_ENTER_SINGLE" Type="Icon" Visible="true" Enabled="TrackingTime='1'" Description="%EnterSingleTooltip%" CommandID="qbw:timeactivity" Name="Time / Enter Single Activity">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_ENTER_WEEKLY" Type="Icon" Visible="true" Enabled="TrackingTime='1'" Description="%EnterWeeklyTooltip%" CommandID="qbw:timecard" Name="Use Weekly Timesheet">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	<SuperNavNode ID="SN_TTS_VIEW" Type="Icon" Visible="true" Enabled="TTSSignedUp='1'" Description="%TTSViewTooltip%" CommandID="qbw:view_download_timesheets_online" Name="View/Download Online Timesheets...">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
<!--Enabled="OnlineBanking.GetNumBanksWithOnlineAccnts !='0'"-->
<!-- ifndef INTL_AU
	<SuperNavNode ID="SN_TTS_SETUP" Type="Icon" Visible="true" Enabled="TTSSignedUp='0'" Description="%TTSSetupTooltip%" CommandID="qbw:learnabout_online_timesheets" Name="Learn about Online Timesheets...">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
endif -->

	<SuperNavNode ID="SN_TTS_EDIT_SETTINGS" Type="Icon" Visible="true" Enabled="TTSSignedUp='1'" Description="%TTSEditSettingsTooltip%" CommandID="qbw:edit_time_tracker_settings" Name="Edit Time Tracker Settings...">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

	<!-- This contains RelatedActivitiesMenu since this is a SuperCommand.
	Business Logic: Supercommands collect multiple closely related commands into one branching icon.  
	There is a visual indication that an icon branches to a menu - a dropdown arrow to the right, defined in IconStyle above.
	Clicking the super command reveals a menu of choices populated from RelatedActivitiesMenu.
    Clicking on any of these menu choices goes to the corresponding feature. -->
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_ENTER_TIMESHEET_SUPERCOMMAND" Type="Icon" Visible="true" Enabled="TrackingTime='1'" Description="%EnterTimesheetSuperCommandTooltip%" CommandID="qbw:SuperNavNonExecuteCommand" Name="Enter&#xD;Time">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_TEJ_TIME"/>
		<IconStyleRef REFID="GENERAL_ICON" />
		<RelatedActivitiesMenu ID="ENTER_TIMESHEET_B_LEVEL">
<!-- ifndef INTL_AU
      <SuperNavNodeRef REFID="SN_TTS_VIEW"/> 
			<SuperNavNodeRef REFID="SN_TTS_EDIT_SETTINGS"/>
			<SuperNavNodeRef REFID="SN_TTS_SETUP"/> 
endif -->
			<SuperNavNodeRef REFID="SN_ENTER_WEEKLY"/>	
			<SuperNavNodeRef REFID="SN_ENTER_SINGLE"/>
		</RelatedActivitiesMenu>
		
	</SuperNavNode>
	
	<SuperNavNode ID="SN_PAYROLL_ONLINE" Type="Icon" Visible="true" Enabled="PROutsourced='1'" Description="%PayrollOnlineTooltip%" CommandID="qbw:do_outsourced_payroll" Name="Process&#xD;Payroll&#xD;Online">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PROCESS_PAYROLL_ONLINE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_DOWNLOAD_PAYROLL" Type="Icon" Visible="true" Enabled="PROutsourced='1'" Description="%DownloadPayrollTooltip%" CommandID="qbw:get_outsourced_payroll_data" Name="Download&#xD;Payroll&#xD;Transactions">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_DOWNLOAD_PAYROLL"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

  <!-- This is the default cross sell icon -->
	<SuperNavNode ID="SN_XSELL_DEF_PAYROLL" Type="Icon" Visible="true" Enabled="Payroll.PrefsPayrollIsIntegrated='1' AND Payroll.PrefsNoPayroll='0' AND Payroll.Assisted='0' AND Payroll.StandardOrEnhanced='0' AND Payroll.StandardOrEnhancedDisk='0' AND PROutsourced='0' AND XSellTest.NewPayrollTestOn='0' AND XSellTest.FreePayrollTestOn='0'" Description="%XSellPayrollTooltip%" CommandID="qbw:PayrollOnlineOfflineLanding" CommandArgs="Action=SuperNav" Name="Learn about &#xD;Payroll Options">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_SIGNUP_PAYROLL"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

  <!-- The "free" version of the cross sell icon -->
  <SuperNavNode ID="SN_XSELL_FREE_PAYROLL" Type="Icon" Visible="true" Enabled="Payroll.PrefsPayrollIsIntegrated='1' AND Payroll.PrefsNoPayroll='0' AND Payroll.Assisted='0' AND Payroll.StandardOrEnhanced='0' AND Payroll.StandardOrEnhancedDisk='0' AND PROutsourced='0' AND XSellTest.FreePayrollTestOn='1'" Description="%XSellPayrollTooltip%" CommandID="qbw:PayrollOnlineOfflineLanding" CommandArgs="Action=SuperNav" Name="FREE&#xD;Payroll Offer">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_SIGNUP_FREE_PAYROLL"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

  <!-- The version that emphasizes the "new" keyword -->
  <SuperNavNode ID="SN_XSELL_NEW_PAYROLL" Type="Icon" Visible="true" Enabled="Payroll.PrefsPayrollIsIntegrated='1' AND Payroll.PrefsNoPayroll='0' AND Payroll.Assisted='0' AND Payroll.StandardOrEnhanced='0' AND Payroll.StandardOrEnhancedDisk='0' AND PROutsourced='0' AND XSellTest.NewPayrollTestOn='1'" Description="%XSellPayrollTooltip%" CommandID="qbw:PayrollOnlineOfflineLanding" CommandArgs="Action=SuperNav" Name="NEW&#xD;Payroll Option">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_SIGNUP_NEW_PAYROLL"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

<!-- ifdef INTL_AU -->
  <SuperNavNode ID="SN_PAYROLL_CENTER2" Type="Icon" Visible="true"
	Enabled="Features.NZLocalised='enabled'" Description="%PayrollCenterTooltip%" CommandID="qbw:Au_PayrollSetup" CommandArgs="context=Dashboard" Name="Payroll&#xD;Centre">
    <ImageItem Type="Icon" Source="qbwin32.dll:ICON_PAYROLL_CENTER"/>
    <IconStyleRef REFID="GENERAL_ICON" />
  </SuperNavNode>
<!-- endif -->

  <!--End of Nodes that are part of Employees Domain-->

	<!--Nodes that are part of Banking Domain-->
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_RECORD_DEPOSITS" Type="Icon" Visible="true" Enabled="true" Description="%RecordDepositsTooltip%" CommandID="qbw:deposit" Name="Record&#xD;Deposits">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_MDEP"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>


<!-- ifdef INTL_AU -->
  <SuperNavNode ID="SN_PRINT_CHECKS" Type="Icon" Visible="true" Enabled="true" Description="%PrintChecksTooltip%" CommandID="qbw:check_print_from_menu" Name="Print&#xD;Cheques">
<!-- else -->
  <!--   <SuperNavNode ID="SN_PRINT_CHECKS" Type="Icon" Visible="true" Enabled="true" Description="%PrintChecksTooltip%" CommandID="qbw:check_print_from_menu" Name="Print&#xD;Checks"> -->
<!-- endif -->
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_PRINT_CHECKS"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

	<SuperNavNode ID="SN_ENTER_CREDIT_CARD_CHARGES" Type="Icon" Visible="true" Enabled="QBlists.IsThereACreditCardAccount !='0'" Description="%EnterCreditCardChargesTooltip%" CommandID="qbw:ccard" Name="Enter Credit&#xD;Card Charges">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_ENTER_CREDIT_CARD_CHARGES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

	<!-- Icon shared with Icon Bar -->
<!-- ifdef INTL_AU -->
  <SuperNavNode ID="SN_CHECK_REGISTER" Type="Icon" Visible="true" Enabled="true" Description="%CheckRegisterTooltip%" CommandID="qbw:open_checkreg" Name="Cheque&#xD;Register">
<!-- else -->
<!--    <SuperNavNode ID="SN_CHECK_REGISTER" Type="Icon" Visible="true" Enabled="true" Description="%CheckRegisterTooltip%" CommandID="qbw:open_checkreg" Name="Check&#xD;Register"> -->
<!-- endif -->
    <ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_REGC"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_RECONCILE" Type="Icon" Visible="true" Enabled="true" Description="%ReconcileTooltip%" CommandID="qbw:reconcile" Name="Reconcile">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_RECONCILE"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
<!-- ifdef INTL_AU -->
	<SuperNavNode ID="SN_WRITE_CHECK" Type="Icon" Visible="true" Enabled="true" Description="%WriteCheckTooltip%" CommandID="qbw:check" Name="Write&#xD;Cheques">
<!-- else -->
  <!-- <SuperNavNode ID="SN_WRITE_CHECK" Type="Icon" Visible="true" Enabled="true" Description="%WriteCheckTooltip%" CommandID="qbw:check" Name="Write&#xD;Checks"> -->
<!-- endif -->
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_WRITECHK"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	<!--End of Banking Domain-->
	
	<!--Company Domain-->
	<SuperNavNode ID="SN_BUILD_ASSEMBLY" Type="Icon" Visible="true" Enabled="Features.ITM_AssemblyItem='enabled' AND Inventory='1'" Description="%BuildAssembliesTooltip%" CommandID="qbw:buildassembly" Name="Build&#xD;Assemblies">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_BUILD_ASSEMBLIES"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<SuperNavNode ID="SN_ADJUST_QTY" Type="Icon" Visible="true" Enabled="Inventory='1'" Description="%AdjustQtyTooltip%" CommandID="qbw:adjust_qnty_onhand" Name="Adjust&#xD;Quantity&#xD;On Hand">
		<ImageItem Type="Icon" Source="qbwin32.dll:ICON_ADJUST_QTY_HAND"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_ITEMS_SERVICES" Type="Icon" Visible="true" Enabled="true" Description="%ItemsServicesTooltip%" CommandID="qbw:items" Name="Items &amp;&#xD;Services">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_ITEMLIST"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>
	
	<!-- Icon shared with Icon Bar -->
	<SuperNavNode ID="SN_CHART_OF_ACCOUNTS" Type="Icon" Visible="true" Enabled="true" Description="%ChartOfAccountsTooltip%" CommandID="qbw:accounts" Name="Chart of&#xD;Accounts">
		<ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_ACCNTLIST"/>
		<IconStyleRef REFID="GENERAL_ICON" />
	</SuperNavNode>

  <!-- ifdef INTL_AU -->
  <!-- Icon shared with Icon Bar -->
   <!--<SuperNavNode ID="SN_BUSINESS_TOOLS" Type="Icon" Visible="true" Enabled="Preferences.UseGoogle='1'" Description="%BusinessTooltip%" CommandID="qbw:LaunchGBT" Name="Marketing&#xD;Tools">
         <ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_BUSINESS_TOOLS"/>
        <IconStyleRef REFID="GENERAL_ICON" /> 
  </SuperNavNode>-->
  <!-- endif -->

  <!-- IFDEF INTL_AU ShiY-->
  <!-- Icon shared with Icon Bar -->
  <SuperNavNode ID="SN_AUDIT_COMPANY_FILE" Type="Icon" Visible="true" Enabled="true" Description="%AuditCompanyFile%" CommandID="qbw:acf_wizard" Name="Audit&#xD;Company">
    <ImageItem Type="Icon" Source="qbwin32.dll:IB_CTB_AUDITCOMPANYFILE"/>
    <IconStyleRef REFID="GENERAL_ICON" />
  </SuperNavNode>
  <!-- ENDIF INTL_AU-->
  
  <!--End of Nodes that are part of Company Domain-->
	
	<!-- Connection points -->
	<!-- Business Logic: they are not part of the user visible design.  They indicate invisible connection points that represent
	vertices of the line segments.  Connection points support the logic of arrows and arrowhead internally
	Some connection points lie on the border between 2 sections.  In this case 2 connection points are defined for each section at 
	the same position.-->
	<!-- A note on connection points naming convention: SNCP=SuperNav Connection Point
														Next are starting icon(s) that the point connects
														Next are the ending icon(s) that the point connects
														Next are the tempates that the connection point is part of, separated by underscore. 
	-->
											
	
	<!--Customers domain Connection Points -->
	<SuperNavNode ID="SNCP_SALESORDER_INVOICES_TC3" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_FINANCESTATEMENTCHARGES_BILLINGSTATEMENTS_TC2" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	
	
	<!--Customers to Banking Connection Points -->
	<SuperNavNode ID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_DEPOSITS_CUSTOMERS_TB" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
		
	<!--Customers to suppliers Connection Points -->
	<SuperNavNode ID="SNCP_ESTIMATESSALESORDERS_PO_TC1_TC3" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_PO_ESTIMATESSALESORDERS_TV1" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_ENTERBILLS_INVOICES_TV1_TV2" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_INVOICES_ENTERBILLS_TC1_TC3" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	
	<!--suppliers domain Connection Points -->
	<SuperNavNode ID="SNCP_ENTERBILLSBILLSAGAINSTINTVENTORY_PAYBILLS_TV1" Type="ConnectionPoint" Visible="true" Enabled="false" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	
	<!--Employees to Customers Connection Poinst -->
	<SuperNavNode ID="SNCP_TIMESHEETS_INVOICES_TE0_TE1_TE2" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	<SuperNavNode ID="SNCP_INVOICES_TIMESHEETS_TC1_TC3" Type="ConnectionPoint" Visible="true" Enabled="true" Description="" CommandID="qbw:SuperNavNonExecuteCommand" Name=""/>
	
	<!-- Line between 2 nodes
		Enable: This should contain logic that is absolute to this line and not to nodes
		it is connecting to. That logic would be checked by controller, ref. to its connected nodes.
		Note: It will not have name as it does not have visible name
	-->
	<!-- A note on lines naming convention: SNL = SuperNav Line
											Starting Icon/Connection Point
											Ending Icon/Connection Point
											Templates that the line is part of (i.e. TC1 = Template Customers 1)
	-->
	
	<!-- Business Logic: Arrows are used to convey to the user the relationship and sequencing of tasks in QuickBooks.
		 Arrows are sensitive to the icons they are connected to.  
		 If an icon is not connected to anything it does not have a connecting arrow.  
		 Arrows are not clickable, there is no action on them or tooltips. -->
		 
	<!-- StartPoint is always top left, EndPoint - bottom right -even if the arrowhead points in a different direction -->
	
	<!-- supplier Domain Lines -->
	<SuperNavLine ID="SNL_PO_RECEIVEINVENTORY_TV1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_PURCHASE_ORDERS" />
		<EndPointRef REFID="SN_RECEIVE_SUPERCOMMAND" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_RECEIVEINVENTORY_BILLSAGAINSTINVENTORY_TV1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_RECEIVE_SUPERCOMMAND" />
		<EndPointRef REFID="SN_BILLS_AGAINST_INVENTORY" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_BILLSAGAINSTINTVENTORY_CP_TV1" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_BILLS_AGAINST_INVENTORY" />
		<EndPointRef REFID="SNCP_ENTERBILLSBILLSAGAINSTINTVENTORY_PAYBILLS_TV1" />
	</SuperNavLine>

	<SuperNavLine ID="SNL_CP_PAYBILLS_TV1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_ENTERBILLSBILLSAGAINSTINTVENTORY_PAYBILLS_TV1" />
		<EndPointRef REFID="SN_PAYBILLS" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_ENTERBILLS_CP_TV1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_ENTER_BILLS" />
		<EndPointRef REFID="SNCP_ENTERBILLSBILLSAGAINSTINTVENTORY_PAYBILLS_TV1" />
	</SuperNavLine>

  <!-- ifdef INTL_AU_RCTI -->
  <!--SuperNavLine ID="SNL_BILLSAGAINSTINTVENTORY_RCTI_TV1" Enabled="Inventory='1'" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
    <LineStyleRef REFID="DarkLine" />
    <StartPointRef REFID="SN_RECEIVE_SUPERCOMMAND" />
    <EndPointRef REFID="SN_RCTI" />
  </SuperNavLine-->
  <!--endif-->
  
	<SuperNavLine ID="SNL_ENTERBILLS_EDGECP_TV1_TV2" Enabled="(Preferences.UseAP='1' OR Inventory='1') AND Preferences.UseInvoices='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SN_ENTER_BILLS" />
		<EndPointRef REFID="SNCP_ENTERBILLS_INVOICES_TV1_TV2" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_EDGECP_PO_TV1" Enabled="Inventory='1' AND Estimating='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_PURCHASE_ORDERS" />
		<EndPointRef REFID="SNCP_PO_ESTIMATESSALESORDERS_TV1" />
	</SuperNavLine>
	
	
	<SuperNavLine ID="SNL_ENTERBILLS_PAYBILLS_TV2" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_ENTER_BILLS" />
		<EndPointRef REFID="SN_PAYBILLS" />
	</SuperNavLine>
	
	
	<!-- Customer Domain Lines -->
	<SuperNavLine ID="SNL_ESTIMATES_SALESORDERS_TC3" Enabled="true" Orientation="Vert" ArrowheadState="Always" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_SALESORDER" />
		<EndPointRef REFID="SN_ESTIMATES" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_SALESORDERS_EDGECP_TC3" Enabled="Inventory='1' AND Estimating='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_ESTIMATESSALESORDERS_PO_TC1_TC3" />
		<EndPointRef REFID="SN_SALESORDER" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_SALESORDERS_CP_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SN_SALESORDER" />
		<EndPointRef REFID="SNCP_SALESORDER_INVOICES_TC3" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_EDGECP_CP_TC3" Enabled="(Preferences.UseAP='1' OR Inventory='1') AND Preferences.UseInvoices='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SNCP_INVOICES_ENTERBILLS_TC1_TC3" />
		<EndPointRef REFID="SNCP_SALESORDER_INVOICES_TC3" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_CP_INVOICES_TC3" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SNCP_SALESORDER_INVOICES_TC3" />
		<EndPointRef REFID="SN_INVOICE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_ESTIMATES_INVOICES_TC1_TC3" Enabled="true" Orientation="Horz" ArrowheadState="Always" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_ESTIMATES" />
		<EndPointRef REFID="SN_INVOICE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_EDGECP_INVOICES_TC1_TC3" Enabled="TrackingTime='1' AND Preferences.UseInvoices='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SN_INVOICE" />
		<EndPointRef REFID="SNCP_INVOICES_TIMESHEETS_TC1_TC3" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_INVOICES_CP_TC1_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_INVOICE" />
		<EndPointRef REFID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_CP_RECEIVEPAYMENTS_TC1_TC3" Enabled="true" Orientation="Horz" ArrowheadState="Always" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3" />
		<EndPointRef REFID="SN_RECPAYMENT" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_STATEMENTCHARGES_FINANCECHARGES_TC1_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_STATEMENT_CHARGES" />
		<EndPointRef REFID="SN_FINANCE_CHARGE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_FINANCECHARGES_STATEMENTS_TC1_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_FINANCE_CHARGE" />
		<EndPointRef REFID="SN_STATEMENTS" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_STATEMENTS_CP_TC1_TC3" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3" />
		<EndPointRef REFID="SN_STATEMENTS" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_RECPAYMENTS_CP_TC1_TC2_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_RECPAYMENT" />
		<EndPointRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_CP_CP_TC1_TC2_TC3" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3" />
		<EndPointRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_CP_EDGECP_TC1_TC2_TC3_TC4" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4" />
		<EndPointRef REFID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_SALESRECEIPTS_CP_TC1_TC2_TC3" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_SALESRECEIPT" />
		<EndPointRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3" />
	</SuperNavLine>

  <!-- INTL_AU ShiY-->
	<!-- SuperNavLine ID="SNL_ONLINEPMTS_CP_TC1_TC2_TC3_TC4" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND" />
		<EndPointRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4" />
	</SuperNavLine -->
  <!-- End INTL_AU-->
	
	<SuperNavLine ID="SNL_EDGECP_INVOICES_TC1" Enabled="(Preferences.UseAP='1' OR Inventory='1') AND Preferences.UseInvoices='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SNCP_INVOICES_ENTERBILLS_TC1_TC3" />
		<EndPointRef REFID="SN_INVOICE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_ESTIMATES_EDGECP_TC1" Enabled="Inventory='1' AND Estimating='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_ESTIMATESSALESORDERS_PO_TC1_TC3" />
		<EndPointRef REFID="SN_ESTIMATES" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_STATEMENTCHARGES_CP_TC2" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_STATEMENT_CHARGES" />
		<EndPointRef REFID="SNCP_FINANCESTATEMENTCHARGES_BILLINGSTATEMENTS_TC2" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_FINANCECHARGES_CP_TC2" Enabled="true" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_FINANCESTATEMENTCHARGES_BILLINGSTATEMENTS_TC2" />
		<EndPointRef REFID="SN_FINANCE_CHARGE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_CP_STATEMENTS_TC2" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_FINANCESTATEMENTCHARGES_BILLINGSTATEMENTS_TC2" />
		<EndPointRef REFID="SN_STATEMENTS" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_STATEMENTS_RECPAYMENT_TC2" Enabled="true" Orientation="Horz" ArrowheadState="Always" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_STATEMENTS" />
		<EndPointRef REFID="SN_RECPAYMENT" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_SALESRECEIPT_CP_TC4" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_SALESRECEIPT" />
		<EndPointRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4" />
	</SuperNavLine>
	
	<!-- Employee Domain Lines -->
	<SuperNavLine ID="SNL_TIMESHEETS_EDGECP_TE0_TE1_TE2" Enabled="TrackingTime='1' AND Preferences.UseInvoices='1'" Orientation="Vert" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="Start">
		<LineStyleRef REFID="LightLine" />
		<StartPointRef REFID="SNCP_TIMESHEETS_INVOICES_TE0_TE1_TE2" />
		<EndPointRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_TIMESHEETS_PAYEMPLOYEES_TE1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
		<EndPointRef REFID="SN_PAY_EMPLOYEES" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_PAYEMPLOYEES_PAYLIABILITIES_TE1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_PAY_EMPLOYEES" />
		<EndPointRef REFID="SN_PAY_LIABILITIES" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_PAYLIABILITIES_PROCESSPAYROLLFORMS_TE1" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_PAY_LIABILITIES" />
		<EndPointRef REFID="SN_PROCESS_PAYROLL_FORMS" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_ENTERTIMESHEETS_PAYROLLONLINE_TE2" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
		<EndPointRef REFID="SN_PAYROLL_ONLINE" />
	</SuperNavLine>
	
	<SuperNavLine ID="SNL_PAYROLLONLINE_DOWNLOADPAYROLL_TE2" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SN_PAYROLL_ONLINE" />
		<EndPointRef REFID="SN_DOWNLOAD_PAYROLL" />
	</SuperNavLine>
	
	
	<!-- Banking Domain Lines -->
	<SuperNavLine ID="SNL_EDGECP_DEPOSITS_TB" Enabled="true" Orientation="Horz" ArrowheadState="ShowIfEndOfIconAndTerminate" ArrowPosition="End">
		<LineStyleRef REFID="DarkLine" />
		<StartPointRef REFID="SNCP_DEPOSITS_CUSTOMERS_TB" />
		<EndPointRef REFID="SN_RECORD_DEPOSITS" />
	</SuperNavLine>
	
	<!-- Company Domain Lines: NO LINES!-->
	
	<!-- Business Logic: Templates correspond to the most common use cases among the user base.  
		 Not every template includes all icons.  If the user turns on a feature that is not 
		 supported by the current template, then a different template will automatically be selected.  
		 The effect in the UI is that some icons may be in slightly different positions when the user 
		 returns from preferences or the customization process. -->
	<!-- Domain Layout templates, collection of nodes and lines in a given domain template.
		NOTE: There would be multiple of these, corresponding one to one with 
		Visual Design templates.
	-->	
	<!--supplier DOMAIN -->
	<!--The supplier section can be turned off completely, if there is no sales tax and if A/P is off and if inventory is off-->
	Template V1 is used if the company file has inventory turned on.  
	POs, inventory and Receive Bills appear in unison in this template.
    If inventory is on, enter bills and pay bills access points are forced on.  
    (This does not change the preference; just the visibility of the icons.)
    -->

	<SuperNavDomainLayout ID="VENDOR_DOMAIN_TV1" Visible="Inventory='1'">
		<!-- Nodes containing X, Y pixel location-->
		<SuperNavNodeLocation CenterX="46" CenterY="12">
			<SuperNavNodeRef REFID="SN_PURCHASE_ORDERS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="52">
			<SuperNavNodeRef REFID="SN_ENTER_BILLS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="238" CenterY="12">
			<SuperNavNodeRef REFID="SN_BILLS_AGAINST_INVENTORY" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="142" CenterY="12">
			<SuperNavNodeRef REFID="SN_RECEIVE_SUPERCOMMAND" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="52">
			<SuperNavNodeRef REFID="SN_PAYBILLS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="354" CenterY="12">
			<SuperNavNodeRef REFID="SN_SALES_TAX_MANAGER" />
		</SuperNavNodeLocation>
    <!--ifdef INTL_AU_RCTI-->
    <!--SuperNavNodeLocation CenterX="142" CenterY="64">
      <SuperNavNodeRef REFID="SN_RCTI" />
    </SuperNavNodeLocation-->
    <!--endif-->
		<!-- Connection Points -->
		<SuperNavNodeLocation CenterX="46" CenterY="81">
			<SuperNavNodeRef REFID="SNCP_PO_ESTIMATESSALESORDERS_TV1" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="81">
			<SuperNavNodeRef REFID="SNCP_ENTERBILLS_INVOICES_TV1_TV2" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="238" CenterY="52">
			<SuperNavNodeRef REFID="SNCP_ENTERBILLSBILLSAGAINSTINTVENTORY_PAYBILLS_TV1" />
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_PO_RECEIVEINVENTORY_TV1"/>
		<SuperNavLineRef REFID="SNL_RECEIVEINVENTORY_BILLSAGAINSTINVENTORY_TV1"/>
		<SuperNavLineRef REFID="SNL_BILLSAGAINSTINTVENTORY_CP_TV1"/>
		<SuperNavLineRef REFID="SNL_CP_PAYBILLS_TV1"/>
		<SuperNavLineRef REFID="SNL_ENTERBILLS_CP_TV1"/>
		<SuperNavLineRef REFID="SNL_ENTERBILLS_EDGECP_TV1_TV2"/>
		<SuperNavLineRef REFID="SNL_EDGECP_PO_TV1"/>
    <!--ifdef INTL_AU_RCTI-->
    <!--SuperNavLineRef REFID="SNL_BILLSAGAINSTINTVENTORY_RCTI_TV1"/-->
    <!--endif-->
	</SuperNavDomainLayout> 
	
	<!--Template V2 is for businesses that do accounts/payable, but do not do inventory.  It is rebalanced for this purpose-->
	<SuperNavDomainLayout ID="VENDOR_DOMAIN_TV2" Visible="Inventory='0' AND (SalesTax='1' OR Preferences.UseAP='1')">
		<!-- Nodes containing X, Y pixel location-->
		<SuperNavNodeLocation CenterX="99" CenterY="36">
			<SuperNavNodeRef REFID="SN_ENTER_BILLS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="276" CenterY="36">
			<SuperNavNodeRef REFID="SN_PAYBILLS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="351" CenterY="36">
			<SuperNavNodeRef REFID="SN_SALES_TAX_MANAGER" />
		</SuperNavNodeLocation>
    <!--ifdef INTL_AU_RCTI-->
    <!--SuperNavNodeLocation CenterX="142" CenterY="64">
      <SuperNavNodeRef REFID="SN_RCTI" />
    </SuperNavNodeLocation-->
    <!--endif-->
		<!-- Connection Points -->
		<SuperNavNodeLocation CenterX="99" CenterY="81">
			<SuperNavNodeRef REFID="SNCP_ENTERBILLS_INVOICES_TV1_TV2" />
		</SuperNavNodeLocation>www
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_ENTERBILLS_PAYBILLS_TV2"/>
		<SuperNavLineRef REFID="SNL_ENTERBILLS_EDGECP_TV1_TV2"/>
				
	</SuperNavDomainLayout> 
	
	<!--CUSTOMER TEMPLATES -->
	<!-- Tempate C1 is for businesses which invoice but do not do sales orders. -->
	<SuperNavDomainLayout ID="CUSTOMER_DOMAIN_TC1"  Visible="Preferences.UseInvoices='1' AND (Features.SOT_SalesOrderTracking='disabled' OR SalesOrders='0')">
		<SuperNavNodeLocation CenterX="46" CenterY="57">
			<SuperNavNodeRef REFID="SN_ESTIMATES"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="270" CenterY="14">
			<SuperNavNodeRef REFID="SN_SALESRECEIPT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="57">
			<SuperNavNodeRef REFID="SN_INVOICE"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="176" CenterY="92">
			<SuperNavNodeRef REFID="SN_FINANCE_CHARGE"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="223" CenterY="92">
			<SuperNavNodeRef REFID="SN_STATEMENTS"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="129" CenterY="92">
			<SuperNavNodeRef REFID="SN_STATEMENT_CHARGES"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="252" CenterY="57">
			<SuperNavNodeRef REFID="SN_RECPAYMENT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="92">
			<SuperNavNodeRef REFID="SN_REFUNDS"/>
		</SuperNavNodeLocation>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavNodeLocation CenterX="333" CenterY="14">
			<SuperNavNodeRef REFID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND"/>
		</SuperNavNodeLocation -->
    <!-- End INTL_AU-->
		
		<!--Connection Points -->
		<SuperNavNodeLocation CenterX="223" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3"/>
		</SuperNavNodeLocation> 
		<SuperNavNodeLocation CenterX="270" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3"/>
		</SuperNavNodeLocation> 
		<SuperNavNodeLocation CenterX="333" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation > 
		<SuperNavNodeLocation CenterX="380" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation> 
		<SuperNavNodeLocation CenterX="99" CenterY="120">
			<SuperNavNodeRef REFID="SNCP_INVOICES_TIMESHEETS_TC1_TC3"/>
		</SuperNavNodeLocation> 
		<SuperNavNodeLocation CenterX="46" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_ESTIMATESSALESORDERS_PO_TC1_TC3"/>
		</SuperNavNodeLocation> 
		<SuperNavNodeLocation CenterX="99" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_INVOICES_ENTERBILLS_TC1_TC3"/>
		</SuperNavNodeLocation> 
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_ESTIMATES_INVOICES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_EDGECP_INVOICES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_INVOICES_CP_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_RECEIVEPAYMENTS_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_STATEMENTCHARGES_FINANCECHARGES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_FINANCECHARGES_STATEMENTS_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_STATEMENTS_CP_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_RECPAYMENTS_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_EDGECP_TC1_TC2_TC3_TC4"/>
		<SuperNavLineRef REFID="SNL_SALESRECEIPTS_CP_TC1_TC2_TC3"/>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavLineRef REFID="SNL_ONLINEPMTS_CP_TC1_TC2_TC3_TC4"/ -->
    <!-- End INTL_AU-->
		<SuperNavLineRef REFID="SNL_EDGECP_INVOICES_TC1"/>
		<SuperNavLineRef REFID="SNL_ESTIMATES_EDGECP_TC1"/>
				
	</SuperNavDomainLayout> 
	
	<!--Template C2 is for service-based businesses such as lawyers or 
	accountants that record individual statement charges for discrete services, 
	and later send out billing statements.  This template would also be used by membership or 
	subscription based businesses such as gym.  Invoices are not used (if they are, the template reverts to C1). 
	-->
	
	<SuperNavDomainLayout ID="CUSTOMER_DOMAIN_TC2"  Visible="Preferences.UseInvoices='0' AND Preferences.UseCreateStatements='1' AND (Features.SOT_SalesOrderTracking='disabled' OR SalesOrders='0')">
		<SuperNavNodeLocation CenterX="270" CenterY="14">
			<SuperNavNodeRef REFID="SN_SALESRECEIPT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="129" CenterY="92">
			<SuperNavNodeRef REFID="SN_FINANCE_CHARGE"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="175" CenterY="57">
			<SuperNavNodeRef REFID="SN_STATEMENTS"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="57">
			<SuperNavNodeRef REFID="SN_STATEMENT_CHARGES"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="252" CenterY="57">
			<SuperNavNodeRef REFID="SN_RECPAYMENT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="92">
			<SuperNavNodeRef REFID="SN_REFUNDS"/>
		</SuperNavNodeLocation>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavNodeLocation CenterX="333" CenterY="14">
			<SuperNavNodeRef REFID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND"/>
		</SuperNavNodeLocation -->
    <!-- End INTL_AU-->
		
		<!--Connection Points -->
		<SuperNavNodeLocation CenterX="129" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_FINANCESTATEMENTCHARGES_BILLINGSTATEMENTS_TC2"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="270" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="380" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_RECPAYMENTS_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_EDGECP_TC1_TC2_TC3_TC4"/>
		<SuperNavLineRef REFID="SNL_SALESRECEIPTS_CP_TC1_TC2_TC3"/>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavLineRef REFID="SNL_ONLINEPMTS_CP_TC1_TC2_TC3_TC4"/ -->
    <!-- End INTL_AU-->
		<SuperNavLineRef REFID="SNL_STATEMENTCHARGES_CP_TC2"/>
		<SuperNavLineRef REFID="SNL_FINANCECHARGES_CP_TC2"/>
		<SuperNavLineRef REFID="SNL_CP_STATEMENTS_TC2"/>
		<SuperNavLineRef REFID="SNL_STATEMENTS_RECPAYMENT_TC2"/>
		
	</SuperNavDomainLayout> 
	
	<!--Template C3 is for businesses that record sales orders, such as manufactures and wholesalers-->
	<SuperNavDomainLayout ID="CUSTOMER_DOMAIN_TC3"  Visible="Features.SOT_SalesOrderTracking='enabled' AND SalesOrders='1'">
		<SuperNavNodeLocation CenterX="46" CenterY="57">
			<SuperNavNodeRef REFID="SN_ESTIMATES"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="46" CenterY="14">
			<SuperNavNodeRef REFID="SN_SALESORDER"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="270" CenterY="14">
			<SuperNavNodeRef REFID="SN_SALESRECEIPT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="57">
			<SuperNavNodeRef REFID="SN_INVOICE"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="176" CenterY="92">
			<SuperNavNodeRef REFID="SN_FINANCE_CHARGE"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="223" CenterY="92">
			<SuperNavNodeRef REFID="SN_STATEMENTS"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="129" CenterY="92">
			<SuperNavNodeRef REFID="SN_STATEMENT_CHARGES"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="252" CenterY="57">
			<SuperNavNodeRef REFID="SN_RECPAYMENT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="92">
			<SuperNavNodeRef REFID="SN_REFUNDS"/>
		</SuperNavNodeLocation>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavNodeLocation CenterX="333" CenterY="14">
			<SuperNavNodeRef REFID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND"/>
		</SuperNavNodeLocation -->
    <!-- End INTL_AU-->
		
		<!--Connection Points -->
		<SuperNavNodeLocation CenterX="223" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_INVOICESSTATEMENTS_RECPAYMENTS_TC1_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="270" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_SALESRECEIPTS_DEPOSITS_TC1_TC2_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="380" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="120">
			<SuperNavNodeRef REFID="SNCP_INVOICES_TIMESHEETS_TC1_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="14">
			<SuperNavNodeRef REFID="SNCP_SALESORDER_INVOICES_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="46" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_ESTIMATESSALESORDERS_PO_TC1_TC3"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_INVOICES_ENTERBILLS_TC1_TC3"/>
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_ESTIMATES_SALESORDERS_TC3"/>
		<SuperNavLineRef REFID="SNL_SALESORDERS_EDGECP_TC3"/>
		<SuperNavLineRef REFID="SNL_SALESORDERS_CP_TC3"/>
		<SuperNavLineRef REFID="SNL_EDGECP_CP_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_INVOICES_TC3"/>
		<SuperNavLineRef REFID="SNL_ESTIMATES_INVOICES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_EDGECP_INVOICES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_INVOICES_CP_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_RECEIVEPAYMENTS_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_STATEMENTCHARGES_FINANCECHARGES_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_FINANCECHARGES_STATEMENTS_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_STATEMENTS_CP_TC1_TC3"/>
		<SuperNavLineRef REFID="SNL_RECPAYMENTS_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_CP_TC1_TC2_TC3"/>
		<SuperNavLineRef REFID="SNL_CP_EDGECP_TC1_TC2_TC3_TC4"/>
		<SuperNavLineRef REFID="SNL_SALESRECEIPTS_CP_TC1_TC2_TC3"/>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavLineRef REFID="SNL_ONLINEPMTS_CP_TC1_TC2_TC3_TC4"/ -->
    <!-- End INTL_AU-->
					
	</SuperNavDomainLayout> 
	
	<!--Template C4 is for retailers, which have simple, 
	anonymous transactions with their customers: they do neither 
	invoices nor sales orders nor statement charges.  
	(If they do, the template reverts to one of the others above.)
	-->
	<SuperNavDomainLayout ID="CUSTOMER_DOMAIN_TC4"  Visible="Preferences.UseInvoices='0' AND Preferences.UseCreateStatements='0' AND (Features.SOT_SalesOrderTracking='disabled' OR SalesOrders='0') AND Preferences.UseSalesReceipts='1'">
		<SuperNavNodeLocation CenterX="175" CenterY="57">
			<SuperNavNodeRef REFID="SN_SALESRECEIPT"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="333" CenterY="92">
			<SuperNavNodeRef REFID="SN_REFUNDS"/>
		</SuperNavNodeLocation>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavNodeLocation CenterX="333" CenterY="14">
			<SuperNavNodeRef REFID="SN_GET_ONLINE_PAYMENTS_SUPERCOMMAND"/>
		</SuperNavNodeLocation -->
    <!-- End INTL_AU-->
		
		<!--Connection Points -->
		<SuperNavNodeLocation CenterX="333" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_ONLINEPMTS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="380" CenterY="57">
			<SuperNavNodeRef REFID="SNCP_CUSTOMERS_DEPOSITS_TC1_TC2_TC3_TC4"/>
		</SuperNavNodeLocation> 
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_CP_EDGECP_TC1_TC2_TC3_TC4"/>
    <!-- INTL_AU ShiY-->
		<!-- SuperNavLineRef REFID="SNL_ONLINEPMTS_CP_TC1_TC2_TC3_TC4"/ -->
    <!-- End INTL_AU-->
		<SuperNavLineRef REFID="SNL_SALESRECEIPT_CP_TC4"/>
				
	</SuperNavDomainLayout> 
	
	<!--EMPLOYEE TEMPLATES -->	
	<!--If the user has indicated that they do have employees, 
	but they not presently signed up for a payroll service, 
	there is an icon which links to a page for payroll information.  
	-->
	<SuperNavDomainLayout ID="EMPLOYEE_DOMAIN_TE0" Visible="(Payroll.PrefsPayrollIsIntegrated='1' AND Payroll.PrefsNoPayroll='0' AND
															 Payroll.Assisted='0' AND 
															 Payroll.StandardOrEnhanced='0' AND Payroll.StandardOrEnhancedDisk='0' AND 
															 PROutsourced='0' AND 
															 Payroll.AllowManualCalc='0') OR 
															 (Payroll.PrefsPayrollIsIntegrated='0' AND Payroll.PrefsNoPayroll='1' AND TrackingTime='1')">
		<SuperNavNodeLocation CenterX="99" CenterY="22">
			<SuperNavNodeRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
		</SuperNavNodeLocation>

    <!-- Only one of the following should show up -->
    <SuperNavNodeLocation CenterX="232" CenterY="22">
			<SuperNavNodeRef REFID="SN_XSELL_DEF_PAYROLL" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="232" CenterY="22">
			<SuperNavNodeRef REFID="SN_XSELL_NEW_PAYROLL" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="232" CenterY="22">
			<SuperNavNodeRef REFID="SN_XSELL_FREE_PAYROLL" />
		</SuperNavNodeLocation>
    
<!-- ifdef INTL_AU -->
    <SuperNavNodeLocation CenterX="223" CenterY="22">
      <SuperNavNodeRef REFID="SN_PAYROLL_CENTER2" />
    </SuperNavNodeLocation>
<!-- endif -->

    <!-- Connection Points -->
		<SuperNavNodeLocation CenterX="99" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_TIMESHEETS_INVOICES_TE0_TE1_TE2" />
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_TIMESHEETS_EDGECP_TE0_TE1_TE2"/>
				
	</SuperNavDomainLayout> 
	
	<!--Template E1 is used for users who have Standard Payroll, Enhanced Payroll or Assisted Payroll.-->
	<SuperNavDomainLayout ID="EMPLOYEE_DOMAIN_TE1" Visible="(Payroll.PrefsPayrollIsIntegrated='1' AND Payroll.PrefsNoPayroll='0') AND 
															(Payroll.Assisted='1' OR 
															((Payroll.StandardOrEnhanced='1' OR Payroll.StandardOrEnhancedDisk='1' OR Payroll.AllowManualCalc='1') AND PROutsourced='0'))">
		<!-- Nodes containing X, Y pixel location-->
		<SuperNavNodeLocation CenterX="54" CenterY="22">
			<SuperNavNodeRef REFID="SN_PAYROLL_CENTER" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="168" CenterY="22">
			<SuperNavNodeRef REFID="SN_PAY_EMPLOYEES" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="232" CenterY="22">
			<SuperNavNodeRef REFID="SN_PAY_LIABILITIES" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="296" CenterY="22">
			<SuperNavNodeRef REFID="SN_PROCESS_PAYROLL_FORMS" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="99" CenterY="22">
			<SuperNavNodeRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
		</SuperNavNodeLocation>

    <!-- Only one should show up, if at all -->
    <SuperNavNodeLocation CenterX="47" CenterY="22">
      <SuperNavNodeRef REFID="SN_XSELL_DEF_PAYROLL" />
    </SuperNavNodeLocation>
    <SuperNavNodeLocation CenterX="47" CenterY="22">
      <SuperNavNodeRef REFID="SN_XSELL_NEW_PAYROLL" />
    </SuperNavNodeLocation>
    <SuperNavNodeLocation CenterX="47" CenterY="22">
      <SuperNavNodeRef REFID="SN_XSELL_FREE_PAYROLL" />
    </SuperNavNodeLocation>

    <!-- Connection Points -->
		<SuperNavNodeLocation CenterX="99" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_TIMESHEETS_INVOICES_TE0_TE1_TE2" />
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_TIMESHEETS_EDGECP_TE0_TE1_TE2"/>
		<SuperNavLineRef REFID="SNL_TIMESHEETS_PAYEMPLOYEES_TE1"/>
		<SuperNavLineRef REFID="SNL_PAYEMPLOYEES_PAYLIABILITIES_TE1"/>
		<SuperNavLineRef REFID="SNL_PAYLIABILITIES_PROCESSPAYROLLFORMS_TE1"/>
				
	</SuperNavDomainLayout> 
	
	<!--Template E2 is for users who have signed up for complete payroll.-->
	<SuperNavDomainLayout ID="EMPLOYEE_DOMAIN_TE2" Visible="PROutsourced='1'">
		<SuperNavNodeLocation CenterX="99" CenterY="22">
			<SuperNavNodeRef REFID="SN_ENTER_TIMESHEET_SUPERCOMMAND" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="232" CenterY="22">
			<SuperNavNodeRef REFID="SN_PAYROLL_ONLINE" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="296" CenterY="22">
			<SuperNavNodeRef REFID="SN_DOWNLOAD_PAYROLL" />
		</SuperNavNodeLocation>
		
		<!-- Connection Points -->
		<SuperNavNodeLocation CenterX="99" CenterY="0">
			<SuperNavNodeRef REFID="SNCP_TIMESHEETS_INVOICES_TE0_TE1_TE2" />
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_TIMESHEETS_EDGECP_TE0_TE1_TE2"/>
		<SuperNavLineRef REFID="SNL_ENTERTIMESHEETS_PAYROLLONLINE_TE2"/>
		<SuperNavLineRef REFID="SNL_PAYROLLONLINE_DOWNLOADPAYROLL_TE2"/>
				
	</SuperNavDomainLayout> 
	
	<!--BANKING TEMPLATES -->
	<!--There is only one Banking template:-->
	<SuperNavDomainLayout ID="BANKING_DOMAIN_DEFAULT" Visible="true">
		<!-- Nodes containing X, Y pixel location-->
		<SuperNavNodeLocation CenterX="31" CenterY="32">
			<SuperNavNodeRef REFID="SN_RECORD_DEPOSITS" />
		</SuperNavNodeLocation>

		<SuperNavNodeLocation CenterX="31" CenterY="112">
			<SuperNavNodeRef REFID="SN_PRINT_CHECKS" />
		</SuperNavNodeLocation>

		<SuperNavNodeLocation CenterX="76" CenterY="112">
			<SuperNavNodeRef REFID="SN_ENTER_CREDIT_CARD_CHARGES" />
		</SuperNavNodeLocation>

		<SuperNavNodeLocation CenterX="76" CenterY="70">
            <SuperNavNodeRef REFID="SN_CHECK_REGISTER" />
		</SuperNavNodeLocation>

		<SuperNavNodeLocation CenterX="76" CenterY="32">
			<SuperNavNodeRef REFID="SN_RECONCILE" />
		</SuperNavNodeLocation>

		<SuperNavNodeLocation CenterX="31" CenterY="70">
			<SuperNavNodeRef REFID="SN_WRITE_CHECK" />
		</SuperNavNodeLocation>
		
		<!-- Connection Points -->
		<SuperNavNodeLocation CenterX="0" CenterY="32">
			<SuperNavNodeRef REFID="SNCP_DEPOSITS_CUSTOMERS_TB" />
		</SuperNavNodeLocation>
		
		<!-- Lines -->
		<SuperNavLineRef REFID="SNL_EDGECP_DEPOSITS_TB"/>
				
	</SuperNavDomainLayout> 
	
	<!--COMPANY TEMPLATES -->
	<!--There is only one company template-->
	<SuperNavDomainLayout ID="COMPANY_DOMAIN_DEFAULT" Visible="true">
		<!-- Nodes containing X, Y pixel location-->
		<SuperNavNodeLocation CenterX="76" CenterY="18">
			<SuperNavNodeRef REFID="SN_BUILD_ASSEMBLY" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="76" CenterY="47">
			<SuperNavNodeRef REFID="SN_ADJUST_QTY" />
		</SuperNavNodeLocation>	
		<SuperNavNodeLocation CenterX="31" CenterY="47">
			<SuperNavNodeRef REFID="SN_ITEMS_SERVICES" />
		</SuperNavNodeLocation>
		<SuperNavNodeLocation CenterX="31" CenterY="18">
			<SuperNavNodeRef REFID="SN_CHART_OF_ACCOUNTS" />
		</SuperNavNodeLocation>
    <!-- ifdef INTL_AU -->
    <!--<SuperNavNodeLocation CenterX="31" CenterY="82"> 
        <SuperNavNodeRef REFID="SN_BUSINESS_TOOLS" />
    </SuperNavNodeLocation>-->
    <!-- endif -->
    <!-- IFDEF INTL_AU ShiY-->
    <SuperNavNodeLocation CenterX="76" CenterY="82">
      <SuperNavNodeRef REFID="SN_AUDIT_COMPANY_FILE" />
    </SuperNavNodeLocation>
    <!-- ENDIF INTL_AU-->
  </SuperNavDomainLayout> -->


<!-- Domain -->
	<!-- represents a specific domain -->	
	<!-- This label is a clickable button. Clicking it opens the Vendor POM.  
		Therefore, we have a tooltip here and rolling over this label provides rollover feedback - rollover image changes. -->
	<SuperNavDomain ID="VENDOR_DOMAIN" Description="%VendorDomainTooltip%">
		<MarginHorz>3</MarginHorz>
		<MarginVert>2</MarginVert>
		<NormalImage  Type="Bitmap" Source="qbdomain.dll:IDB_SN_VENDOR_POM"/>
		<RolloverImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_VENDOR_POM_ROLLOVER" />

		<BackgroundStyle Color="#E5F0F3" />
		<TitleCommandID>qbw:vendor_domain</TitleCommandID>
				
		<!-- Choose one template from all the declared ones. Should be only one visible at a time -->
		<SuperNavDomainLayoutRef REFID="VENDOR_DOMAIN_TV1"/>
		<SuperNavDomainLayoutRef REFID="VENDOR_DOMAIN_TV2"/>
	</SuperNavDomain>
	
	<!-- This label is a clickable button. Clicking it opens the Customer POM.  
		Therefore, we have a tooltip here and rolling over this label provides rollover feedback - rollover image changes. -->
	<SuperNavDomain ID="CUSTOMER_DOMAIN" Description="%CustomerDomainTooltip%">
		<NormalImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_CUSTOMER_POM">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'">
			<Source>qbdomain.dll:IDB_SN_DONOR_POM</Source>
		</If>
		</NormalImage>
		<RolloverImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_CUSTOMER_POM_ROLLOVER">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'">
			<Source>qbdomain.dll:IDB_SN_DONOR_POM_ROLLOVER</Source>
		</If>
		</RolloverImage>

		<MarginHorz>3</MarginHorz>
		<MarginVert>2</MarginVert>
		<BackgroundStyle Color="#E5F0F3"/>
		<TitleCommandID>qbw:customer_domain</TitleCommandID>
		
		<!-- Choose one template from all the declared ones. Should be only one visible at a time -->
        <SuperNavDomainLayoutRef REFID="CUSTOMER_DOMAIN_TC1" />
        <SuperNavDomainLayoutRef REFID="CUSTOMER_DOMAIN_TC2" />
        <SuperNavDomainLayoutRef REFID="CUSTOMER_DOMAIN_TC3" />
        <SuperNavDomainLayoutRef REFID="CUSTOMER_DOMAIN_TC4" />
	</SuperNavDomain>
	
	<!-- This label is a clickable button. Clicking it opens the Employee POM.  
		Therefore, we have a tooltip here and rolling over this label provides rollover feedback - rollover image changes. --> 
	<SuperNavDomain ID="EMPLOYEE_DOMAIN" Description="%EmployeeDomainTooltip%">
		<MarginHorz>3</MarginHorz>
		<MarginVert>2</MarginVert>
		<NormalImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_EMPLOYEE_POM"/>
		<RolloverImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_EMPLOYEE_POM_ROLLOVER"/>

		<BackgroundStyle Color="#E5F0F3"/>
		<TitleCommandID>qbw:employee_domain?context=EmpListEmpTxn</TitleCommandID>

    <!-- Choose one template from all the declared ones. Should be only one visible at a time -->
		<SuperNavDomainLayoutRef REFID="EMPLOYEE_DOMAIN_TE0"/>
		<SuperNavDomainLayoutRef REFID="EMPLOYEE_DOMAIN_TE1"/>
		<SuperNavDomainLayoutRef REFID="EMPLOYEE_DOMAIN_TE2"/>
	</SuperNavDomain>
	
	<!-- Not clickable, hence no tooltip, and the rollover image is the same as the normal one-->
	<SuperNavDomain ID="BANKING_DOMAIN" Description="">
		<MarginHorz>3</MarginHorz>
		<MarginVert>2</MarginVert>
		<NormalImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_BANKING"/>
		<RolloverImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_BANKING"/>

		<BackgroundStyle Color="#E5F0F3"/>
		<TitleCommandID>qbw:SuperNavNonExecuteCommand</TitleCommandID>
		
		
		<!-- Choose one template from all the declared ones. Should be only one visible at a time -->
		<SuperNavDomainLayoutRef REFID="BANKING_DOMAIN_DEFAULT"/>
	</SuperNavDomain>
	
	<!-- Not clickable, hence no tooltip, and the rollover image is the same as the normal one -->
	<SuperNavDomain ID="COMPANY_DOMAIN" Description="">
		<MarginHorz>3</MarginHorz>
		<MarginVert>2</MarginVert>
		<NormalImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_COMPANY"/>
		<RolloverImage Type="Bitmap" Source="qbdomain.dll:IDB_SN_COMPANY"/>

		<BackgroundStyle Color="#E5F0F3"/>
		<TitleCommandID>qbw:SuperNavNonExecuteCommand</TitleCommandID>
		
		<!-- Choose one template from all the declared ones. Should be only one visible at a time -->
		<SuperNavDomainLayoutRef REFID="COMPANY_DOMAIN_DEFAULT"/>
	</SuperNavDomain>
	
	<!-- The container for all the domains.  Domains select an appropriate template based on preferences.  Only one tempate is visible at any one time -->
	<SuperNav ID="SuperNav" MaxWidth="1200" MaxHeight="388">
		<SuperNavArea ID="VENDORS_DOMAIN_AREA" Top="0" Left="0" Width="380" Height="81">
			<SuperNavDomainRef REFID="VENDOR_DOMAIN"/>
		</SuperNavArea> 
		<SuperNavArea ID="CUSTOMER_DOMAIN_AREA" Top="81" Left="0" Width="380" Height="120">
			<SuperNavDomainRef REFID="CUSTOMER_DOMAIN"/>
		</SuperNavArea> 
		<SuperNavArea ID="EMPLOYEES_DOMAIN_AREA" Top="201" Left="0" Width="380" Height="61">
			<SuperNavDomainRef REFID="EMPLOYEE_DOMAIN"/>
		</SuperNavArea> 
		<SuperNavArea ID="BANKING_DOMAIN_AREA" Top="106" Left="380" Width="113" Height="156">
			<SuperNavDomainRef REFID="BANKING_DOMAIN"/>
		</SuperNavArea> 
		<SuperNavArea ID="COMPANY_DOMAIN_AREA" Top="0" Left="380" Width="113" Height="106">
			<SuperNavDomainRef REFID="COMPANY_DOMAIN"/> 
		</SuperNavArea> 
		
	</SuperNav> 
	
	
<Dictionary ID="SuperNavTooltips" IsFixedAtStartup="false">
	<!-- SKU Specific Tooltips -->
	<!-- Vendor section tooltips -->
	<Entry Token="VendorDomainTooltip" Value="Go to the Supplier Centre to view your supplier list and to manage supplier data and transactions" UsesAn="false">
		<If test="Application.SKU = 'contractor' OR Application.SKU='belcontractor'" Value="Go to the supplier Center to  view your suppliers and subcontractors and to manage supplier data and transactions"/>
	</Entry>	
		
	<Entry Token="PurchaseOrdersTooltip" Value="Create a purchase order to submit to your supplier" UsesAn="false">
		<If test="Application.SKU = 'contractor' OR Application.SKU='belcontractor'" Value="Create a purchase order to submit to your supplier or subcontractor"/>
		<ElseIf test="Application.SKU = 'wholesale' OR Application.SKU='belwholesale'" Value="Create a purchase order to submit to your supplier"/>
		<ElseIf test="Application.SKU = 'retail' OR Application.SKU='belretail'" Value="Create a purchase order to submit to your supplier"/>
	</Entry>	
		
	<Entry Token="EnterBillsTooltip" Value="Enter outstanding bills from suppliers" UsesAn="false">
		<If test="Application.SKU = 'contractor' OR Application.SKU='belcontractor'" Value="Enter outstanding bills from suppliers or subcontractors"/>
		<ElseIf test="Application.SKU = 'wholesale' OR Application.SKU='belwholesale'" Value="Enter outstanding bills from suppliers"/>
		<ElseIf test="Application.SKU = 'retail' OR Application.SKU='belretail'" Value="Enter outstanding bills and credits from suppliers"/>
	</Entry>																							
		
	<Entry Token="EnterBillsAgainstInventoryTooltip" Value="Enter a bill for items you have already received" UsesAn="false">
	</Entry>
		
	<Entry Token="ReceiveWithBillTooltip" Value="Record receipt of inventory items if they arrived with the bill" UsesAn="false">
	</Entry>
		
	<Entry Token="ReceiveWithoutBillTooltip" Value="Record receipt of inventory items if they arrived without a bill (to update your inventory)" UsesAn="false">
	</Entry>
		
	<Entry Token="ReceiveSuperCommandTooltip" Value="Record receipt of inventory items that arrived with a bill or without a bill to keep your inventory up to date" UsesAn="false">
	</Entry>
		
	<Entry Token="PayBillsTooltip" Value="Pay outstanding bills you have already entered into QuickBooks" UsesAn="false">
	</Entry>

<!-- ifdef INTL_AU-->
  <Entry Token="SalesTaxManagerTooltip" Value="Manage common tax tasks" UsesAn="false">
<!-- else -->
<!--  <Entry Token="SalesTaxManagerTooltip" Value="Manage common sales tax tasks" UsesAn="false"> -->
<!-- endif -->
  </Entry>
		
	<!-- Customer Section Tooltips -->
	<Entry Token="CustomerDomainTooltip" Value="Go to the Customer Centre to view your customer list and to manage customer data and transactions" UsesAn="false">
		<If test="Application.SKU = 'contractor' OR Application.SKU='belcontractor'" Value="Go to the Customer Center to view your customers and jobs and to manage customer data and transactions"/>
		<ElseIf test="Application.SKU = 'accountant' OR Application.SKU='belacct'" Value="Go to the Customer Center to view your client list and to manage client data and transactions"/>
		<ElseIf test="Application.SKU = 'professional' OR Application.SKU='belprofessional'" Value="Go to the Customer Center to view your clients and projects and to manage client data and transactions"/>
		<ElseIf test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Go to the Customer Center to view your donor list and to manage donor data and transactions"/>
	</Entry>
		
	<Entry Token="EstimatesTooltip" Value="Create a new estimate, quote, proposal, or bid" UsesAn="false">
		<If test="Application.SKU = 'wholesale' OR Application.SKU='belwholesale'" Value="Create a new quote, estimate, proposal, or bid"/>
		<ElseIf test="Application.SKU = 'professional' OR Application.SKU='belprofessional'" Value="Create a new proposal, estimate, quote, or bid"/>
		<ElseIf test="Application.SKU = 'retail' OR Application.SKU='belretail'" Value="Create a new quote, estimate, proposal, or bid"/>
	</Entry>
		
	<Entry Token="SalesOrdersTooltip" Value="Create a new sales order to keep track of items that your customers have agreed to buy" UsesAn="false">
	</Entry>
		
	<Entry Token="SalesReceiptTooltip" Value="Bill your customer and receive the payment at the same time" UsesAn="false">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Enter a new donation  for money you have received"/>
		<ElseIf test="Application.SKU = 'retail' OR Application.SKU='belretail'" Value="Record sales for goods and services"/>
	</Entry>
		
	<Entry Token="InvoicesTooltip" Value="Bill your customer and receive the payment later" UsesAn="false">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Enter a new pledge"/>
	</Entry>
		
	<Entry Token="FinanceChargeTooltip" Value="Assess late fees for overdue charges" UsesAn="false">
	</Entry>
		
	<Entry Token="StatementsTooltip" Value="Create a new statement to show your customers a history of their account activity (charges, payments, and balance)" UsesAn="false">
		<If test="Application.SKU = 'accountant' OR Application.SKU='belacct'" Value="Create a new statement to show your clients a history of their account activity (charges, payments, and balance)"/>
		<ElseIf test="Application.SKU = 'professional' OR Application.SKU='belprofessional'" Value="Create a client billing statement for accumulated charges"/>
		<ElseIf test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Create a new statement to show your donors a history of their pledge fulfillment"/>
	</Entry>
		
	<Entry Token="StatementsChargesTooltip" Value="Accumulate charges that will be included on a billing statement" UsesAn="false">
	</Entry>
	
	<Entry Token="ReceivePaymentsTooltip" Value="Record a payment you have received from a customer against an invoice or billing statement" UsesAn="false">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Record a payment to fulfill a pledge"/>
	</Entry>
		
	<Entry Token="RefundsTooltip" Value="Issue an adjustment note to credit a customer for product refunds, service refunds, or credit toward an account" UsesAn="false">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Return a donation"/>
	</Entry>
	
	<Entry Token="BillingSolutionsTooltip" Value="Download credit card payments made online" UsesAn="false">
	</Entry>
	
	<Entry Token="VirtualTerminalTooltip" Value="Download credit card transactions processed outside of QuickBooks from any computer with Internet access" UsesAn="false">
	</Entry>
	
	<Entry Token="AutomaticCCBillingTooltip" Value="Download credit card payments billed and processed as recurring charges" UsesAn="false">
	</Entry>
	
	<Entry Token="TerminalDownloadTooltip" Value="Download credit card payments processed through a credit card terminal" UsesAn="false">
	</Entry>
	
	<Entry Token="GetOnlinePaymentsSuperCommandTooltip" Value="Download credit card payments" UsesAn="false">
	</Entry>
	
	<!-- Employee Section Tooltips -->
	<Entry Token="EmployeeDomainTooltip" Value="Go to the Employee Centre to view your employee list and to manage employee data, transactions, and payroll" UsesAn="false">
	</Entry>

<!-- ifdef INTL_AU -->
  <Entry Token="PayrollCenterTooltip" Value="Go to the Payroll Centre to pay employees, create payments, and access payment summaries" UsesAn="false">
  </Entry>

  <Entry Token="PayEmployeesTooltip" Value="Pay employees by cheque or direct deposit" UsesAn="false">
  </Entry>

  <Entry Token="PayLiabilitiesTooltip" Value="Pay your taxes and other payroll liabilities" UsesAn="false">
  </Entry>

  <Entry Token="ProcessPayrollFormsTooltip" Value="Create Payment Summaries" UsesAn="false">
  </Entry>
<!-- else -->
  <!-- <Entry Token="PayrollCenterTooltip" Value="Go to the Payroll Centre to pay employees, create checks for tax deposits, access payroll tax forms, and download the latest payroll updates" UsesAn="false">
	</Entry>
	
	<Entry Token="PayEmployeesTooltip" Value="Pay employees by check or direct deposit" UsesAn="false">
	</Entry>
	
	<Entry Token="PayLiabilitiesTooltip" Value="Pay your taxes and other payroll liabilities (Federal, State, 401k, etc.)" UsesAn="false">
	</Entry>
	
	<Entry Token="ProcessPayrollFormsTooltip" Value="Create Federal or State payroll forms" UsesAn="false">
	</Entry> -->
<!-- endif -->
	
	<Entry Token="EnterSingleTooltip" Value="Enter the time spent by one person doing a single activity on a single job on a single date " UsesAn="false">
	</Entry>
	
	<Entry Token="EnterWeeklyTooltip" Value="Fill out a weekly timesheet for an employee or contractor" UsesAn="false">
	</Entry>

	<Entry Token="TTSDownloadTooltip" Value="" UsesAn="false">
	</Entry>

	<Entry Token="TTSSetupTooltip" Value="" UsesAn="false">
	</Entry>

	<Entry Token="TTSEditSettingsTooltip" Value="" UsesAn="false">
	</Entry>

	<Entry Token="TTSViewStatusTooltip" Value="" UsesAn="false">
	</Entry>
	
	<Entry Token="EnterTimesheetSuperCommandTooltip" Value="Record time that an employee has spent on a customer or job, and use this information for billing, job costing, or payroll" UsesAn="false">
	</Entry>
	
	<Entry Token="PayrollOnlineTooltip" Value="Do your payroll over the Internet" UsesAn="false">
	</Entry>
	
	<Entry Token="DownloadPayrollTooltip" Value="Get your latest transactions over the internet" UsesAn="false">
	</Entry>
			
	<Entry Token="XSellPayrollTooltip" Value="Learn about efficient and cost-effective solutions for in-house or assisted payroll processing" UsesAn="false">
	</Entry>
	
	<!-- Banking Section Tooltips -->
	<Entry Token="RecordDepositsTooltip" Value="Record the deposit of one or more customer payments to your bank account" UsesAn="false">
		<If test="Application.SKU = 'nonprofit' OR Application.SKU = 'belnonprofit'" Value="Record the deposit of one or more donations to your bank account"/>
	</Entry>

<!-- ifdef INTL_AU -->
  <Entry Token="PrintChecksTooltip" Value="Review cheques that have been recorded in QuickBooks and select the cheques you want to print" UsesAn="false">
<!-- else -->
  <!-- <Entry Token="PrintChecksTooltip" Value="Review checks and/or paychecks that have been recorded in QuickBooks and select the checks you want to print" UsesAn="false"> -->
<!-- endif -->
	</Entry>

	<Entry Token="EnterCreditCardChargesTooltip" Value="Enter your business credit card charges" UsesAn="false">
	</Entry>

	<Entry Token="CheckRegisterTooltip" Value="Open a bank account register to view a sorted list of transactions with a running balance" UsesAn="false">
	</Entry>
	
	<Entry Token="ReconcileTooltip" Value="Match transactions in your QuickBooks account against your bank statement" UsesAn="false">
	</Entry>

  <!-- ifdef INTL_AU -->
  <Entry Token="WriteCheckTooltip" Value="Write cheques for an expense that you have not entered as a bill in QuickBooks, or to record a cash transaction" UsesAn="false">
	</Entry>
  <!-- else -->
  <!--   <Entry Token="WriteCheckTooltip" Value="Write cheques for an expense that you have not entered as a bill in QuickBooks, or to record a cash transaction" UsesAn="false"> -->
  <!--   </Entry> -->
  <!-- endif -->
	
	<!-- Company Section Tooltips -->
	<Entry Token="BuildAssembliesTooltip" Value="Build assembly items from components" UsesAn="false">
	</Entry>
	
	<Entry Token="AdjustQtyTooltip" Value="Adjust quantity of inventory items on hand" UsesAn="false">
	</Entry>
	
	<Entry Token="ItemsServicesTooltip" Value="View and modify the list of items and services you sell" UsesAn="false">
	</Entry>
	
	<Entry Token="ChartOfAccountsTooltip" Value="View and modify your QuickBooks accounts (bank, income, expense, etc.)" UsesAn="false">
	</Entry>
  <Entry Token="BusinessTooltip" Value="Attract new customers using Google Marketing Tools" UsesAn="false">
  </Entry>
  <!-- IFDEF INTL_AU ShiY-->
  <Entry Token="AuditCompanyFile" Value="Audit your company file" UsesAn="false">
  </Entry>
  <!-- ENDIF INTL_AU-->
</Dictionary>
</AppDef>
