src/examples/list-horizontal/.sencha/app/page-impl.xml

   1 <project name="page-impl.xml">
   2
   3     <macrodef name="x-build-microload-markup">
   4         <sequential>
   5             <if>
   6                 <x-is-true value="${build.enable.embedded.microloader}"/>
   7                 <then>
   8                     <x-sencha-command dir="${app.dir}" inheritall="true">
   9                         <![CDATA[
  10                         fs
  11                             minify
  12                                 ${build.embedded.microloader.compressor}
  13                                 -from=${build.microloader.path}
  14                                 -to=${build.microloader.path}
  15                         ]]>
  16                     </x-sencha-command>
  17                     <x-run-if-true value="${app.output.page.enable}">
  18                         <x-compile refid="${compiler.ref.id}">
  19                             <![CDATA[
  20                             markup
  21                                 -contentFile=${build.microloader.path}
  22                                 -tpl=${build.embedded.microloader.tpl}
  23                                 -out=${build.out.page.path}
  24                             ]]>
  25                         </x-compile>
  26                         <!--once the generated microloader file is embedded, delete it-->
  27                         <delete file="${build.microloader.path}"/>
  28                     </x-run-if-true>
  29                 </then>
  30                 <else>
  31                     <x-run-if-true value="${app.output.page.enable}">
  32                         <x-compile refid="${compiler.ref.id}">
  33                             <![CDATA[
  34                             markup
  35                                 -markup=${build.external.microloader.markup}
  36                                 -out=${build.out.page.path}
  37                             ]]>
  38                         </x-compile>
  39                     </x-run-if-true>
  40                 </else>
  41             </if>
  42         </sequential>
  43     </macrodef>
  44
  45     <target name="-build-output-manifest-page">
  46         <local name="metadata.base.path"/>
  47         <property name="metadata.base.path" value="${build.out.metadata.dir}"/>
  48         <x-run-if-true value="${app.output.manifest.enable}">
  49             <if>
  50                 <x-is-true value="${build.enable.embedded.manifest}"/>
  51                 <then>
  52                     <x-compile refid="${compiler.ref.id}">
  53                         <![CDATA[
  54                         # generate microloader file
  55                         # generate json file
  56                         microload
  57                             -operation=manifest
  58                             -tpl=${build.microloader.json.tpl.embedded}
  59                             -out=${build.microloader.path}
  60                             -resourcePath=${build.out.base.path}
  61                             -basePath=${metadata.base.path}
  62                         and
  63                         microload
  64                             -append
  65                             -operation=microloader
  66                             -microloaderPath=${app.microloader.path}
  67                             -bootPath=${build.boot.file}
  68                             -tpl=${build.microloader.code.tpl}
  69                             -out=${build.microloader.path}
  70                         ]]>
  71                     </x-compile>
  72                 </then>
  73                 <else>
  74                     <x-compile refid="${compiler.ref.id}">
  75                         <![CDATA[
  76                         # generate json file
  77                         microload
  78                             -operation=manifest
  79                             -tpl=${build.microloader.json.tpl.standalone}
  80                             -out=${build.out.json.path}
  81                             -resourcePath=${build.out.base.path}
  82                             -basePath=${metadata.base.path}
  83                         and
  84                         microload
  85                             -operation=manifest
  86                             -tpl=${build.microloader.json.tpl.external}
  87                             -out=${build.microloader.path}
  88                             -resourcePath=${build.out.base.path}
  89                             -basePath=${metadata.base.path}
  90                         and
  91                         # generate microloader file
  92                         microload
  93                             -append
  94                             -operation=microloader
  95                             -microloaderPath=${app.microloader.path}
  96                             -bootPath=${build.boot.file}
  97                             -tpl=${build.microloader.code.tpl}
  98                             -out=${build.microloader.path}
  99                         ]]>
 100                     </x-compile>
 101                 </else>
 102             </if>
 103         </x-run-if-true>
 104         <x-build-microload-markup/>
 105     </target>
 106
 107     <target name="-build-output-microload-page">
 108         <if>
 109             <x-is-true value="${build.enable.embedded.manifest}"/>
 110             <then>
 111                 <x-compile refid="${compiler.ref.id}">
 112                     <![CDATA[
 113                     # generate microloader file
 114                     microload
 115                         -operation=microloader
 116                         -microloaderPath=${app.microloader.path}
 117                         -tpl=${build.microloader.code.tpl}
 118                         -out=${build.microloader.path}
 119                     and
 120                     # generate json file
 121                     microload
 122                         -operation=json
 123                         -append
 124                         -tpl=${build.microloader.json.tpl.embedded}
 125                         -out=${build.microloader.path}
 126                     ]]>
 127                 </x-compile>
 128             </then>
 129             <else>
 130                 <x-compile refid="${compiler.ref.id}">
 131                     <![CDATA[
 132                     # generate json file
 133                     microload
 134                         -operation=json
 135                         -tpl=${build.microloader.json.tpl.standalone}
 136                         -out=${build.out.json.path}
 137                     and
 138                     # generate microloader file
 139                     microload
 140                         -operation=microloader
 141                         -microloaderPath=${app.microloader.path}
 142                         -tpl=${build.microloader.code.tpl}
 143                         -out=${build.microloader.path}
 144                     and
 145                     microload
 146                         -operation=json
 147                         -append
 148                         -tpl=${build.microloader.json.tpl.external}
 149                         -out=${build.microloader.path}
 150                     ]]>
 151                 </x-compile>
 152             </else>
 153         </if>
 154         <x-build-microload-markup/>
 155     </target>
 156
 157     <!-- generates a separate json manifest for use with native packager -->
 158     <target name="-build-standalone-json-manifest">
 159         <x-run-if-true value="${enable.standalone.manifest}">
 160             <x-compile refid="${compiler.ref.id}">
 161                 <![CDATA[
 162                 # generate json file
 163                 microload
 164                     -operation=json
 165                     -tpl=${build.microloader.json.tpl.standalone}
 166                     -out=${build.out.json.path}
 167                 ]]>
 168             </x-compile>
 169         </x-run-if-true>
 170     </target>
 171
 172     <target name="-build-output-markup-page">
 173         <condition property="internal.app.css.rel" value="${app.out.css.rel}">
 174             <x-is-true value="${enable.ext42.themes}"/>
 175         </condition>
 176         <property name="internal.app.css.rel" value=""/>
 177
 178         <x-compile refid="${compiler.ref.id}">
 179             <![CDATA[
 180             markup
 181                 -out=${build.out.page.path}
 182             ]]>
 183         </x-compile>
 184     </target>
 185
 186     <!-- '-detect-app-build-properties' is defined in js-impl.xml -->
 187     <target name="-build-output-page"
 188             depends="-detect-app-build-properties,-build-standalone-json-manifest">
 189         <if>
 190             <x-is-true value="${build.output.markuponly}"/>
 191             <then>
 192                 <x-ant-call target="-build-output-markup-page"/>
 193             </then>
 194             <else>
 195                 <if>
 196                     <x-is-true value="${build.enable.appmanifest}"/>
 197                     <then>
 198                         <x-ant-call target="-build-output-manifest-page"/>
 199                     </then>
 200                     <else>
 201                         <x-ant-call target="-build-output-microload-page"/>
 202                     </else>
 203                 </if>
 204             </else>
 205         </if>
 206     </target>
 207
 208     <target name="-copy-app-resources" depends="-init-compiler">
 209         <x-compile refid="${compiler.ref.id}">
 210             <![CDATA[
 211             app-resources
 212                 -compress=${enable.resource.compression}
 213                 -out=${build.out.base.path}
 214             ]]>
 215         </x-compile>
 216     </target>
 217
 218     <target name="-generate-deltas" depends="-init-compiler">
 219         <x-run-if-true value="${app.output.deltas.enable}">
 220             <if>
 221                 <and>
 222                     <x-is-true value="${enable.deltas}"/>
 223                     <x-is-false value="${build.output.markuponly}"/>
 224                 </and>
 225                 <then>
 226                     <x-compile refid="${compiler.ref.id}">
 227                         <![CDATA[
 228                         deltas
 229                             -archivePath=${build.out.archive.path}
 230                             -deltaPath=${build.out.delta.path}
 231                             -resourcePath=${build.out.base.path}
 232                         ]]>
 233                     </x-compile>
 234                 </then>
 235             </if>
 236         </x-run-if-true>
 237     </target>
 238
 239     <target name="-generate-cache-manifest" depends="-init-compiler">
 240         <x-run-if-true value="${app.output.cache.enable}">
 241             <if>
 242                 <and>
 243                     <x-is-true value="${enable.cache.manifest}"/>
 244                     <x-is-false value="${build.output.markuponly}"/>
 245                 </and>
 246                 <then>
 247                     <x-compile refid="${compiler.ref.id}">
 248                         <![CDATA[
 249                         cache-manifest
 250                             -cacheManifestPath=${build.manifest.path}
 251                         ]]>
 252                     </x-compile>
 253                     <replace file="${build.out.page.path}"
 254                              token="&lt;html manifest=&quot;&quot;"
 255                              value="&lt;html manifest=&quot;${build.manifest.name}&quot;"/>
 256                 </then>
 257             </if>
 258         </x-run-if-true>
 259         <!--remove manifest placeholder if present-->
 260         <replace file="${build.out.page.path}"
 261                  token="&lt;html manifest=&quot;&quot;"
 262                  value="&lt;html"/>
 263     </target>
 264
 265     <target name="-before-page"/>
 266     <target name="-page"
 267             depends="-copy-app-resources,
 268                      -generate-deltas,
 269                      -build-output-page,
 270                      -generate-cache-manifest"/>
 271     <target name="-after-page"/>
 272 </project>