extjs/templates/executive-dashboard/.sencha/app/page-impl.xml

   1 <project name="x-page-impl.xml">
   2
   3     <macrodef name="x-build-microload-markup">
   4         <sequential>
   5             <x-sencha-command dir="${app.dir}" inheritall="true">
   6                 <![CDATA[
   7                 fs
   8                     minify
   9                         ${build.embedded.microloader.compressor}
  10                         -from=${build.microloader.path}
  11                         -to=${build.microloader.path}
  12                 ]]>
  13             </x-sencha-command>
  14             <if>
  15                 <x-is-true value="${build.enable.embedded.microloader}"/>
  16                 <then>
  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                             -fashion=${use.fashion}
  59                             -tpl=${build.microloader.json.tpl.embedded}
  60                             -out=${build.microloader.path}
  61                             -resourcePath=${build.out.base.path}
  62                             -basePath=${metadata.base.path}
  63                         and
  64                         microload
  65                             -append
  66                             -operation=microloader
  67                             -microloaderPath=${app.microloader.path}
  68                             -bootPath=${build.boot.file}
  69                             -tpl=${build.microloader.code.tpl}
  70                             -out=${build.microloader.path}
  71                         ]]>
  72                     </x-compile>
  73                 </then>
  74                 <else>
  75                     <x-compile refid="${compiler.ref.id}">
  76                         <![CDATA[
  77                         # generate json file
  78                         microload
  79                             -operation=manifest
  80                             -fashion=${use.fashion}
  81                             -tpl=${build.microloader.json.tpl.standalone}
  82                             -out=${build.out.json.path}
  83                             -resourcePath=${build.out.base.path}
  84                             -basePath=${metadata.base.path}
  85                         and
  86                         microload
  87                             -operation=manifest
  88                             -fashion=${use.fashion}
  89                             -tpl=${build.microloader.json.tpl.external}
  90                             -out=${build.microloader.path}
  91                             -resourcePath=${build.out.base.path}
  92                             -basePath=${metadata.base.path}
  93                         and
  94                         # generate microloader file
  95                         microload
  96                             -append
  97                             -operation=microloader
  98                             -microloaderPath=${app.microloader.path}
  99                             -bootPath=${build.boot.file}
 100                             -tpl=${build.microloader.code.tpl}
 101                             -out=${build.microloader.path}
 102                         ]]>
 103                     </x-compile>
 104                 </else>
 105             </if>
 106         </x-run-if-true>
 107         <x-build-microload-markup/>
 108     </target>
 109
 110     <target name="-build-output-microload-page">
 111         <if>
 112             <x-is-true value="${build.enable.embedded.manifest}"/>
 113             <then>
 114                 <x-compile refid="${compiler.ref.id}">
 115                     <![CDATA[
 116                     # generate microloader file
 117                     microload
 118                         -operation=microloader
 119                         -microloaderPath=${app.microloader.path}
 120                         -tpl=${build.microloader.code.tpl}
 121                         -out=${build.microloader.path}
 122                     and
 123                     # generate json file
 124                     microload
 125                         -operation=json
 126                         -append
 127                         -tpl=${build.microloader.json.tpl.embedded}
 128                         -out=${build.microloader.path}
 129                     ]]>
 130                 </x-compile>
 131             </then>
 132             <else>
 133                 <x-compile refid="${compiler.ref.id}">
 134                     <![CDATA[
 135                     # generate json file
 136                     microload
 137                         -operation=json
 138                         -tpl=${build.microloader.json.tpl.standalone}
 139                         -out=${build.out.json.path}
 140                     and
 141                     # generate microloader file
 142                     microload
 143                         -operation=microloader
 144                         -microloaderPath=${app.microloader.path}
 145                         -tpl=${build.microloader.code.tpl}
 146                         -out=${build.microloader.path}
 147                     and
 148                     microload
 149                         -operation=json
 150                         -append
 151                         -tpl=${build.microloader.json.tpl.external}
 152                         -out=${build.microloader.path}
 153                     ]]>
 154                 </x-compile>
 155             </else>
 156         </if>
 157         <x-build-microload-markup/>
 158     </target>
 159
 160     <!-- generates a separate json manifest for use with native packager -->
 161     <target name="-build-standalone-json-manifest">
 162         <x-run-if-true value="${enable.standalone.manifest}">
 163             <x-compile refid="${compiler.ref.id}">
 164                 <![CDATA[
 165                 # generate json file
 166                 microload
 167                     -operation=json
 168                     -tpl=${build.microloader.json.tpl.standalone}
 169                     -out=${build.out.json.path}
 170                 ]]>
 171             </x-compile>
 172         </x-run-if-true>
 173     </target>
 174
 175     <target name="-build-output-markup-page">
 176         <condition property="internal.app.css.rel" value="${app.out.css.rel}">
 177             <x-is-true value="${enable.ext42.themes}"/>
 178         </condition>
 179         <property name="internal.app.css.rel" value=""/>
 180
 181         <if>
 182             <isset property="framework.isV5"/>
 183             <then>
 184                 <x-compile refid="${compiler.ref.id}">
 185                     <![CDATA[
 186                     markup
 187                         -out=${build.out.page.path}
 188                         -basePath=${build.out.metadata.dir}
 189                         -resourcePath=${build.out.base.path}
 190                     and
 191                     # generate microloader file
 192                     # generate json file
 193                     microload
 194                         -operation=manifest
 195                         -fashion=${use.fashion}
 196                         -tpl=${build.microloader.json.tpl.embedded}
 197                         -out=${build.microloader.path}
 198                         -resourcePath=${build.out.base.path}
 199                         -basePath=${build.out.metadata.dir}
 200                     ]]>
 201                 </x-compile>
 202                 <x-compress-js srcFile="${build.microloader.path}" outFile="${build.microloader.path}"/>
 203                 <concat destfile="${build.out.js.path}.tmp">
 204                     <fileset file="${build.microloader.path}"/>
 205                     <fileset file="${build.out.js.path}"/>
 206                 </concat>
 207                 <delete file="${build.microloader.path}"/>
 208                 <delete file="${build.out.js.path}"/>
 209                 <move file="${build.out.js.path}.tmp" tofile="${build.out.js.path}"/>
 210             </then>
 211             <else>
 212                 <x-compile refid="${compiler.ref.id}">
 213                     <![CDATA[
 214                     markup
 215                         -out=${build.out.page.path}
 216                         -resourcePath=${build.out.base.path}
 217                         -basePath=${build.out.metadata.dir}
 218                     ]]>
 219                 </x-compile>
 220             </else>
 221         </if>
 222     </target>
 223
 224     <!-- '-detect-app-build-properties' is defined in js-impl.xml -->
 225     <target name="-build-output-page"
 226             depends="-detect-app-build-properties,-build-standalone-json-manifest">
 227         <if>
 228             <x-is-true value="${build.output.markuponly}"/>
 229             <then>
 230                 <x-ant-call target="-build-output-markup-page"/>
 231             </then>
 232             <else>
 233                 <if>
 234                     <x-is-true value="${build.enable.appmanifest}"/>
 235                     <then>
 236                         <x-ant-call target="-build-output-manifest-page"/>
 237                     </then>
 238                     <else>
 239                         <x-ant-call target="-build-output-microload-page"/>
 240                     </else>
 241                 </if>
 242             </else>
 243         </if>
 244     </target>
 245
 246     <target name="-copy-app-resources" depends="-init-compiler">
 247         <x-compile refid="${compiler.ref.id}">
 248             <![CDATA[
 249             app-resources
 250                 -compress=${enable.resource.compression}
 251                 -out=${build.out.base.path}
 252             ]]>
 253         </x-compile>
 254     </target>
 255
 256     <target name="-apply-version-stamps" depends="-init-compiler">
 257         <x-run-if-true value="${app.cache.enable}">
 258             <x-compile refid="${compiler.ref.id}">
 259                 <![CDATA[
 260                 versions
 261                     -resourcePath=${build.out.base.path}
 262                 ]]>
 263             </x-compile>
 264         </x-run-if-true>
 265     </target>
 266
 267     <target name="-generate-deltas" depends="-apply-version-stamps">
 268         <if>
 269             <and>
 270                 <x-is-false value="${skip.deltas}"/>
 271                 <x-is-false value="${build.output.markuponly}"/>
 272             </and>
 273             <then>
 274                 <x-compile refid="${compiler.ref.id}">
 275                     <![CDATA[
 276                     deltas
 277                         -archivePath=${build.out.archive.path}
 278                         -deltaPath=${build.out.deltas.path}
 279                         -resourcePath=${build.out.base.path}
 280                     ]]>
 281                 </x-compile>
 282             </then>
 283         </if>
 284     </target>
 285
 286     <target name="-generate-cache-manifest" depends="-init-compiler">
 287         <if>
 288             <and>
 289                 <x-is-false value="${skip.appCache}"/>
 290                 <x-is-false value="${build.output.markuponly}"/>
 291             </and>
 292             <then>
 293                 <x-compile refid="${compiler.ref.id}">
 294                     <![CDATA[
 295                     cache-manifest
 296                         -cacheManifestPath=${build.manifest.path}
 297                     ]]>
 298                 </x-compile>
 299                 <replace file="${build.out.page.path}"
 300                          token="&lt;html manifest=&quot;&quot;"
 301                          value="&lt;html manifest=&quot;${build.out.appCache.name}&quot;"/>
 302             </then>
 303         </if>
 304         <!--remove manifest placeholder if present-->
 305         <replace file="${build.out.page.path}"
 306                  token="&lt;html manifest=&quot;&quot;"
 307                  value="&lt;html"/>
 308     </target>
 309
 310     <target name="-before-page"/>
 311     <target name="-page"
 312             depends="-copy-app-resources,
 313                      -generate-deltas,
 314                      -build-output-page,
 315                      -generate-cache-manifest"/>
 316     <target name="-after-page"/>
 317 </project>