crm.fsf.org/20131203/files/sites/all/modules-old/ctools/page_manager/plugins/tasks/page.inc

   1 <?php
   2
   3 /**
   4  * @file
   5  * Handle the 'page' task, which creates pages with arbitrary tasks and lets
   6  * handlers decide how they will be rendered.
   7  *
   8  * This creates subtasks and stores them in the page_manager_pages table. These
   9  * are exportable objects, too.
  10  *
  11  * The render callback for this task type has $handler, $page, $contexts as
  12  * parameters.
  13  */
  14
  15 /**
  16  * Specialized implementation of hook_page_manager_task_tasks(). See api-task.html for
  17  * more information.
  18  */
  19 function page_manager_page_page_manager_tasks() {
  20   return array(
  21     'title' => t('Custom pages'),
  22     'description' => t('Administrator created pages that have a URL path, access control and entries in the Drupal menu system.'),
  23     'non-exportable' => TRUE,
  24     'subtasks' => TRUE,
  25     'subtask callback' => 'page_manager_page_subtask',
  26     'subtasks callback' => 'page_manager_page_subtasks',
  27     'save subtask callback' => 'page_manager_page_save_subtask',
  28     'access callback' => 'page_manager_page_access_check',
  29     'hook menu' => array(
  30       'file' => 'page.admin.inc',
  31       'path' => drupal_get_path('module', 'page_manager') . '/plugins/tasks',
  32       'function' => 'page_manager_page_menu',
  33     ),
  34     'hook theme' => 'page_manager_page_theme',
  35     // page only items
  36     'task type' => 'page',
  37     'page operations' => array(
  38       array(
  39         'title' => ' &raquo; ' . t('Create a new page'),
  40         'href' => 'admin/structure/pages/add',
  41         'html' => TRUE,
  42       ),
  43     ),
  44     'columns' => array(
  45       'storage' => array(
  46         'label' => t('Storage'),
  47         'class' => 'page-manager-page-storage',
  48       ),
  49     ),
  50     'page type' => 'custom',
  51
  52     // context only items
  53     'handler type' => 'context',
  54     'get arguments' => array(
  55       'file' => 'page.admin.inc',
  56       'path' => drupal_get_path('module', 'page_manager') . '/plugins/tasks',
  57       'function' => 'page_manager_page_get_arguments',
  58     ),
  59     'get context placeholders' => 'page_manager_page_get_contexts',
  60     'access restrictions' => 'page_manager_page_access_restrictions',
  61     'uses handlers' => TRUE,
  62   );
  63 }
  64
  65 /**
  66  * Task callback to get all subtasks.
  67  *
  68  * Return a list of all subtasks.
  69  */
  70 function page_manager_page_subtasks($task) {
  71   $pages = page_manager_page_load_all($task['name']);
  72   $return = array();
  73   foreach ($pages as $name => $page) {
  74     $return[$name] = page_manager_page_build_subtask($task, $page);
  75   }
  76
  77   return $return;
  78 }
  79
  80 /**
  81  * Callback to return a single subtask.
  82  */
  83 function page_manager_page_subtask($task, $subtask_id) {
  84   $page = page_manager_page_load($subtask_id);
  85   if ($page) {
  86     return page_manager_page_build_subtask($task, $page);
  87   }
  88 }
  89
  90 /**
  91  * Call back from the administrative system to save a page.
  92  *
  93  * We get the $subtask as created by page_manager_page_build_subtask.
  94  */
  95 function page_manager_page_save_subtask($subtask) {
  96   $page = &$subtask['subtask'];
  97
  98   // Ensure $page->arguments contains only real arguments:
  99   $arguments = page_manager_page_get_named_arguments($page->path);
 100   $args = array();
 101   foreach ($arguments as $keyword => $position) {
 102     if (isset($page->arguments[$keyword])) {
 103       $args[$keyword] = $page->arguments[$keyword];
 104     }
 105     else {
 106       $args[$keyword] = array(
 107         'id' => '',
 108         'identifier' => '',
 109         'argument' => '',
 110         'settings' => array(),
 111       );
 112     }
 113   }
 114   page_manager_page_recalculate_arguments($page);
 115   // Create a real object from the cache
 116   page_manager_page_save($page);
 117
 118   // Check to see if we should make this the site frontpage.
 119   if (!empty($page->make_frontpage)) {
 120     $path = array();
 121     foreach (explode('/', $page->path) as $bit) {
 122       if ($bit[0] != '!') {
 123         $path[] = $bit;
 124       }
 125     }
 126
 127     $path = implode('/', $path);
 128     $front = variable_get('site_frontpage', 'node');
 129     if ($path != $front) {
 130       variable_set('site_frontpage', $path);
 131     }
 132   }
 133 }
 134
 135 /**
 136  * Build a subtask array for a given page.
 137  */
 138 function page_manager_page_build_subtask($task, $page) {
 139   $operations = array();
 140   $operations['settings'] = array(
 141     'type' => 'group',
 142     'class' => array('operations-settings'),
 143     'title' => t('Settings'),
 144     'children' => array(),
 145   );
 146
 147   $settings = &$operations['settings']['children'];
 148
 149   $settings['basic'] = array(
 150     'title' => t('Basic'),
 151     'description' => t('Edit name, path and other basic settings for the page.'),
 152     'form' => 'page_manager_page_form_basic',
 153   );
 154
 155   $arguments = page_manager_page_get_named_arguments($page->path);
 156   if ($arguments) {
 157     $settings['argument'] = array(
 158       'title' => t('Arguments'),
 159       'description' => t('Set up contexts for the arguments on this page.'),
 160       'form' => 'page_manager_page_form_argument',
 161     );
 162   }
 163
 164   $settings['access'] = array(
 165     'title' => t('Access'),
 166     'description' => t('Control what users can access this page.'),
 167     'admin description' => t('Access rules are used to test if the page is accessible and any menu items associated with it are visible.'),
 168     'form' => 'page_manager_page_form_access',
 169   );
 170
 171   $settings['menu'] = array(
 172     'title' => t('Menu'),
 173     'description' => t('Provide this page a visible menu or a menu tab.'),
 174     'form' => 'page_manager_page_form_menu',
 175   );
 176
 177   $operations['actions']['children']['clone'] = array(
 178     'title' => t('Clone'),
 179     'description' => t('Make a copy of this page'),
 180     'form' => 'page_manager_page_form_clone',
 181   );
 182   $operations['actions']['children']['export'] = array(
 183     'title' => t('Export'),
 184     'description' => t('Export this page as code that can be imported or embedded into a module.'),
 185     'form' => 'page_manager_page_form_export',
 186   );
 187   if ($page->export_type == (EXPORT_IN_CODE | EXPORT_IN_DATABASE)) {
 188     $operations['actions']['children']['delete'] = array(
 189       'title' => t('Revert'),
 190       'description' => t('Remove all changes to this page and revert to the version in code.'),
 191       'form' => 'page_manager_page_form_delete',
 192     );
 193   }
 194   else if ($page->export_type != EXPORT_IN_CODE) {
 195     $operations['actions']['children']['delete'] = array(
 196       'title' => t('Delete'),
 197       'description' => t('Remove this page from your system completely.'),
 198       'form' => 'page_manager_page_form_delete',
 199     );
 200   }
 201
 202   $subtask = array(
 203     'name' => $page->name,
 204     'admin title' => check_plain($page->admin_title),
 205     'admin description' => filter_xss_admin($page->admin_description),
 206     'admin summary' => 'page_manager_page_admin_summary',
 207     'admin path' => $page->path,
 208     'admin type' => t('Custom'),
 209     'subtask' => $page,
 210     'operations' => $operations,
 211     'operations include' => array(
 212       'file' => 'page.admin.inc',
 213       'path' => drupal_get_path('module', 'page_manager') . '/plugins/tasks',
 214     ),
 215     'single task' => empty($page->multiple),
 216     'row class' => empty($page->disabled) ? 'page-manager-enabled' : 'page-manager-disabled',
 217     'storage' => $page->type == t('Default') ? t('In code') : $page->type,
 218     'disabled' => !empty($page->disabled),
 219     // This works for both enable AND disable
 220     'enable callback' => 'page_manager_page_enable',
 221   );
 222
 223   // default handlers may appear from a default subtask.
 224   if (isset($page->default_handlers)) {
 225     $subtask['default handlers'] = $page->default_handlers;
 226   }
 227   return $subtask;
 228 }
 229
 230 /**
 231  * Delegated implementation of hook_theme().
 232  */
 233 function page_manager_page_theme(&$items, $task) {
 234   $base = array(
 235     'file' => 'page.admin.inc',
 236     'path' => drupal_get_path('module', 'page_manager') . '/plugins/tasks',
 237   );
 238   $items['page_manager_page_form_argument_table'] = $base + array(
 239     'render element' => 'form',
 240   );
 241   $items['page_manager_page_lock'] = $base + array(
 242     'variables' => array('lock' => array(), 'task_name' => NULL),
 243   );
 244   $items['page_manager_page_changed'] = $base + array(
 245     'variables' => array(),
 246   );
 247 }
 248
 249 // --------------------------------------------------------------------------
 250 // Page execution functions
 251
 252 /**
 253  * Execute a page task.
 254  *
 255  * This is the callback to entries in the Drupal menu system created by the
 256  * page task.
 257  *
 258  * @param $subtask_id
 259  *   The name of the page task used.
 260  * @param ...
 261  *   A number of context objects as specified by the user when
 262  *   creating named arguments in the path.
 263  */
 264 function page_manager_page_execute($subtask_id) {
 265   $page = page_manager_page_load($subtask_id);
 266   $task = page_manager_get_task($page->task);
 267   $subtask = page_manager_get_task_subtask($task, $subtask_id);
 268
 269   // Turn the contexts into a properly keyed array.
 270   $contexts = array();
 271   $args = array();
 272   foreach (func_get_args() as $count => $arg) {
 273     if (is_object($arg) && get_class($arg) == 'ctools_context') {
 274       $contexts[$arg->id] = $arg;
 275       $args[] = $arg->original_argument;
 276     }
 277     else if ($count) {
 278       $args[] = $arg;
 279     }
 280   }
 281
 282   $count = 0;
 283   $names = page_manager_page_get_named_arguments($page->path);
 284   $bits = explode('/', $page->path);
 285
 286   if ($page->arguments) {
 287     foreach ($page->arguments as $name => $argument) {
 288       // Optional arguments must be converted to contexts too, if they exist.
 289       if ($bits[$names[$name]][0] == '!') {
 290         ctools_include('context');
 291         $argument['keyword'] = $name;
 292         if (isset($args[$count])) {
 293           // Hack: use a special argument config variable to learn if we need
 294           // to use menu_tail style behavior:
 295           if (empty($argument['settings']['use_tail'])) {
 296             $value = $args[$count];
 297           }
 298           else {
 299             $value = implode('/', array_slice($args, $count));
 300           }
 301
 302           $context = ctools_context_get_context_from_argument($argument, $value);
 303         }
 304         else {
 305           // make sure there is a placeholder context for missing optional contexts.
 306           $context = ctools_context_get_context_from_argument($argument, NULL, TRUE);
 307           // Force the title to blank for replacements
 308         }
 309         if ($context) {
 310           $contexts[$context->id] = $context;
 311         }
 312       }
 313       $count++;
 314     }
 315   }
 316
 317   if ($function = ctools_plugin_get_function($task, 'page callback')) {
 318     return call_user_func_array($function, array($page, $contexts, $args));
 319   }
 320
 321   ctools_include('context-task-handler');
 322   $output = ctools_context_handler_render($task, $subtask, $contexts, $args);
 323   if ($output === FALSE) {
 324     return MENU_NOT_FOUND;
 325   }
 326
 327   return $output;
 328 }
 329
 330 // --------------------------------------------------------------------------
 331 // Context type callbacks
 332
 333 /**
 334  * Return a list of arguments used by this task.
 335  */
 336 function page_manager_page_get_arguments($task, $subtask) {
 337   return _page_manager_page_get_arguments($subtask['subtask']);
 338 }
 339
 340 function _page_manager_page_get_arguments($page) {
 341   $arguments = array();
 342   if (!empty($page->arguments)) {
 343     foreach ($page->arguments as $keyword => $argument) {
 344       if (isset($argument['name'])) {
 345         $argument['keyword'] = $keyword;
 346         $arguments[$keyword] = $argument;
 347       }
 348     }
 349   }
 350   return $arguments;
 351 }
 352
 353 /**
 354  * Get a group of context placeholders for the arguments.
 355  */
 356 function page_manager_page_get_contexts($task, $subtask) {
 357   ctools_include('context');
 358   return ctools_context_get_placeholders_from_argument(page_manager_page_get_arguments($task, $subtask));
 359 }
 360
 361 /**
 362  * Return a list of arguments used by this task.
 363  */
 364 function page_manager_page_access_restrictions($task, $subtask, $contexts) {
 365   $page = $subtask['subtask'];
 366   return ctools_access_add_restrictions($page->access, $contexts);
 367 }
 368
 369 // --------------------------------------------------------------------------
 370 // Page task database info.
 371
 372 /**
 373  * Create a new page with defaults appropriately set from schema.
 374  */
 375 function page_manager_page_new() {
 376   ctools_include('export');
 377   return ctools_export_new_object('page_manager_pages');
 378 }
 379
 380 /**
 381  * Load a single page subtask.
 382  */
 383 function page_manager_page_load($name) {
 384   ctools_include('export');
 385   $result = ctools_export_load_object('page_manager_pages', 'names', array($name));
 386   if (isset($result[$name])) {
 387     return $result[$name];
 388   }
 389 }
 390
 391 /**
 392  * Load all page subtasks.
 393  */
 394 function page_manager_page_load_all($task = NULL) {
 395   ctools_include('export');
 396
 397   if (empty($task)) {
 398     return ctools_export_load_object('page_manager_pages');
 399   }
 400   else {
 401     return ctools_export_load_object('page_manager_pages', 'conditions', array('task' => $task));
 402   }
 403 }
 404
 405 /**
 406  * Write a page subtask to the database.
 407  */
 408 function page_manager_page_save(&$page) {
 409   $update = (isset($page->pid)) ? array('pid') : array();
 410   $task = page_manager_get_task($page->task);
 411
 412   if ($function = ctools_plugin_get_function($task, 'save')) {
 413     $function($page, $update);
 414   }
 415   drupal_write_record('page_manager_pages', $page, $update);
 416
 417   // If this was a default page we may need to write default task
 418   // handlers that we provided as well.
 419   if (!$update && isset($page->default_handlers)) {
 420     $handlers = page_manager_load_task_handlers(page_manager_get_task('page'), $page->name);
 421     foreach ($page->default_handlers as $name => $handler) {
 422       if (!isset($handlers[$name]) || !($handlers[$name]->export_type & EXPORT_IN_DATABASE)) {
 423         // Make sure this is right, as exports can wander a bit.
 424         $handler->subtask = $page->name;
 425         page_manager_save_task_handler($handler);
 426       }
 427     }
 428   }
 429   return $page;
 430 }
 431
 432 /**
 433  * Remove a page subtask.
 434  */
 435 function page_manager_page_delete($page) {
 436   $task = page_manager_get_task($page->task);
 437   if ($function = ctools_plugin_get_function($task, 'delete')) {
 438     $function($page);
 439   }
 440   if (!empty($task['uses handlers'])) {
 441     $handlers = page_manager_load_task_handlers($task, $page->name);
 442     foreach ($handlers as $handler) {
 443       page_manager_delete_task_handler($handler);
 444     }
 445   }
 446   db_delete('page_manager_pages')
 447     ->condition('name', $page->name)
 448     ->execute();
 449   // Make sure that the cache is reset so that the menu rebuild does not
 450   // rebuild this page again.
 451   ctools_include('export');
 452   ctools_export_load_object_reset('page_manager_pages');
 453   menu_rebuild();
 454 }
 455
 456 /**
 457  * Export a page subtask.
 458  */
 459 function page_manager_page_export($page, $with_handlers = FALSE, $indent = '') {
 460   $task = page_manager_get_task($page->task);
 461   $append = '';
 462
 463   if ($function = ctools_plugin_get_function($task, 'export')) {
 464     $append = $function($page, $indent);
 465   }
 466
 467   ctools_include('export');
 468   $output = ctools_export_object('page_manager_pages', $page, $indent);
 469   $output .= $append;
 470
 471   if ($with_handlers) {
 472     if (is_array($with_handlers)) {
 473       $handlers = $with_handlers;
 474     }
 475     else {
 476       $handlers = page_manager_load_task_handlers(page_manager_get_task('page'), $page->name);
 477     }
 478     $output .= $indent . '$page->default_handlers = array();' . "\n";
 479     foreach ($handlers as $handler) {
 480       $output .= page_manager_export_task_handler($handler, $indent);
 481       $output .= $indent . '$page->default_handlers[$handler->name] = $handler;' . "\n";
 482     }
 483   }
 484   return $output;
 485 }
 486
 487 /**
 488  * Get a list of named arguments in a page manager path.
 489  *
 490  * @param $path
 491  *   A normal Drupal path.
 492  *
 493  * @return
 494  *   An array of % marked variable arguments, keyed by the argument's name.
 495  *   The value will be the position of the argument so that it can easily
 496  *   be found. Items with a position of -1 have multiple positions.
 497  */
 498 function page_manager_page_get_named_arguments($path) {
 499   $arguments = array();
 500   $bits = explode('/', $path);
 501   foreach ($bits as $position => $bit) {
 502     if ($bit && ($bit[0] == '%' || $bit[0] == '!')) {
 503       // special handling for duplicate path items and substr to remove the %
 504       $arguments[substr($bit, 1)] = isset($arguments[$bit]) ? -1 : $position;
 505     }
 506   }
 507
 508   return $arguments;
 509 }
 510
 511 /**
 512  * Load a context from an argument for a given page task.
 513  *
 514  * Helper function for pm_arg_load(), which is in page_manager.module because
 515  * drupal's menu system does not allow loader functions to reside in separate
 516  * files.
 517  *
 518  * @param $value
 519  *   The incoming argument value.
 520  * @param $subtask
 521  *   The subtask id.
 522  * @param $argument
 523  *   The numeric position of the argument in the path, counting from 0.
 524  *
 525  * @return
 526  *   A context item if one is configured, the argument if one is not, or
 527  *   FALSE if restricted or invalid.
 528  */
 529 function _pm_arg_load($value, $subtask, $argument) {
 530   $page = page_manager_page_load($subtask);
 531   if (!$page) {
 532     return FALSE;
 533   }
 534
 535   $path = explode('/', $page->path);
 536   if (empty($path[$argument])) {
 537     return FALSE;
 538   }
 539
 540   $keyword = substr($path[$argument], 1);
 541   if (empty($page->arguments[$keyword])) {
 542     return $value;
 543   }
 544
 545   $page->arguments[$keyword]['keyword'] = $keyword;
 546
 547   ctools_include('context');
 548   $context = ctools_context_get_context_from_argument($page->arguments[$keyword], $value);
 549
 550   // convert false equivalents to false.
 551   return $context ? $context : FALSE;
 552 }
 553
 554 /**
 555  * Provide a nice administrative summary of the page so an admin can see at a
 556  * glance what this page does and how it is configured.
 557  */
 558 function page_manager_page_admin_summary($task, $subtask) {
 559   $task_name = page_manager_make_task_name($task['name'], $subtask['name']);
 560   $page = $subtask['subtask'];
 561   $output = '';
 562
 563   $rows = array();
 564
 565   $rows[] = array(
 566     array('class' => array('page-summary-label'), 'data' => t('Storage')),
 567     array('class' => array('page-summary-data'), 'data' => $subtask['storage']),
 568     array('class' => array('page-summary-operation'), 'data' => ''),
 569   );
 570
 571   if (!empty($page->disabled)) {
 572     $link = l(t('Enable'), page_manager_edit_url($task_name, array('handlers', $page->name, 'actions', 'enable')));
 573     $text = t('Disabled');
 574   }
 575   else {
 576     $link = l(t('Disable'), page_manager_edit_url($task_name, array('handlers', $page->name, 'actions', 'disable')));
 577     $text = t('Enabled');
 578   }
 579
 580   $rows[] = array(
 581     array('class' => array('page-summary-label'), 'data' => t('Status')),
 582     array('class' => array('page-summary-data'), 'data' => $text),
 583     array('class' => array('page-summary-operation'), 'data' => $link),
 584   );
 585
 586
 587   $path = array();
 588   foreach (explode('/', $page->path) as $bit) {
 589     if ($bit[0] != '!') {
 590       $path[] = $bit;
 591     }
 592   }
 593
 594   $path = implode('/', $path);
 595   $front = variable_get('site_frontpage', 'node');
 596
 597   $link = l(t('Edit'), page_manager_edit_url($task_name, array('settings', 'basic')));
 598   $message = '';
 599   if ($path == $front) {
 600     $message = t('This is your site home page.');
 601   }
 602   else if (!empty($page->make_frontpage)) {
 603     $message = t('This page is set to become your site home page.');
 604   }
 605
 606   if ($message) {
 607     $rows[] = array(
 608       array('class' => array('page-summary-data'), 'data' => $message, 'colspan' => 2),
 609       array('class' => array('page-summary-operation'), 'data' => $link),
 610     );
 611   }
 612
 613   if (strpos($path, '%') === FALSE) {
 614     $path = l('/' . $page->path, $path);
 615   }
 616   else {
 617     $path = '/' . $page->path;
 618   }
 619
 620   $rows[] = array(
 621     array('class' => array('page-summary-label'), 'data' => t('Path')),
 622     array('class' => array('page-summary-data'), 'data' => $path),
 623     array('class' => array('page-summary-operation'), 'data' => $link),
 624   );
 625
 626   if (empty($access['plugins'])) {
 627     $access['plugins'] = array();
 628   }
 629
 630   $contexts = page_manager_page_get_contexts($task, $subtask);
 631   $access = ctools_access_group_summary($page->access, $contexts);
 632   if ($access) {
 633     $access = t('Accessible only if @conditions.', array('@conditions' => $access));
 634   }
 635   else {
 636     $access = t('This page is publicly accessible.');
 637   }
 638
 639   $link = l(t('Edit'), page_manager_edit_url($task_name, array('settings', 'access')));
 640
 641   $rows[] = array(
 642     array('class' => array('page-summary-label'), 'data' => t('Access')),
 643     array('class' => array('page-summary-data'), 'data' => $access),
 644     array('class' => array('page-summary-operation'), 'data' => $link),
 645   );
 646
 647   $menu_options = array(
 648     'none' => t('No menu entry.'),
 649     'normal' => t('Normal menu entry.'),
 650     'tab' => t('Menu tab.'),
 651     'default tab' => t('Default menu tab.'),
 652     'action' => t('Local action'),
 653   );
 654
 655   if (!empty($page->menu)) {
 656     $menu = $menu_options[$page->menu['type']];
 657     if ($page->menu['type'] != 'none') {
 658       $menu .= ' ' . t('Title: %title.', array('%title' => $page->menu['title']));
 659       switch ($page->menu['type']) {
 660         case 'default tab':
 661           $menu .= ' ' . t('Parent title: %title.', array('%title' => $page->menu['parent']['title']));
 662           break;
 663         case 'normal':
 664           if (module_exists('menu')) {
 665             $menus = menu_get_menus();
 666             $menu .= ' ' . t('Menu block: %title.', array('%title' => $menus[$page->menu['name']]));
 667           }
 668           break;
 669       }
 670     }
 671   }
 672   else {
 673     $menu = t('No menu entry');
 674   }
 675
 676   $link = l(t('Edit'), page_manager_edit_url($task_name, array('settings', 'menu')));
 677   $rows[] = array(
 678     array('class' => array('page-summary-label'), 'data' => t('Menu')),
 679     array('class' => array('page-summary-data'), 'data' => $menu),
 680     array('class' => array('page-summary-operation'), 'data' => $link),
 681   );
 682
 683   $output .= theme('table', array('rows' => $rows, 'attributes' => array('id' => 'page-manager-page-summary')));
 684   return $output;
 685 }
 686
 687 /**
 688  * Callback to enable/disable the page from the UI.
 689  */
 690 function page_manager_page_enable(&$cache, $status) {
 691   $page = &$cache->subtask['subtask'];
 692   ctools_include('export');
 693   ctools_export_set_object_status($page, $status);
 694
 695   $page->disabled = FALSE;
 696 }
 697
 698 /**
 699  * Recalculate the arguments when something like the path changes.
 700  */
 701 function page_manager_page_recalculate_arguments(&$page) {
 702   // Ensure $page->arguments contains only real arguments:
 703   $arguments = page_manager_page_get_named_arguments($page->path);
 704   $args = array();
 705   foreach ($arguments as $keyword => $position) {
 706     if (isset($page->arguments[$keyword])) {
 707       $args[$keyword] = $page->arguments[$keyword];
 708     }
 709     else {
 710       $args[$keyword] = array(
 711         'id' => '',
 712         'identifier' => '',
 713         'argument' => '',
 714         'settings' => array(),
 715       );
 716     }
 717   }
 718   $page->arguments = $args;
 719 }
 720
 721 /**
 722  * When adding or cloning a new page, this creates a new page cache
 723  * and adds our page to it.
 724  *
 725  * This does not check to see if the existing cache is already locked.
 726  * This must be done beforehand.
 727  *
 728  * @param &$page
 729  *   The page to create.
 730  * @param &$cache
 731  *   The cache to use. If the cache has any existing task handlers,
 732  *   they will be marked for deletion. This may be a blank object.
 733  */
 734 function page_manager_page_new_page_cache(&$page, &$cache) {
 735   // Does a page already exist? If so, we are overwriting it so
 736   // take its pid.
 737   if (!empty($cache->subtask) && !empty($cache->subtask['subtask']) && !empty($cache->subtask['subtask']->pid)) {
 738     $page->pid = $cache->subtask['subtask']->pid;
 739   }
 740   else {
 741     $cache->new = TRUE;
 742   }
 743
 744   $cache->task_name = page_manager_make_task_name('page', $page->name);
 745   $cache->task_id = 'page';
 746   $cache->task = page_manager_get_task('page');
 747   $cache->subtask_id = $page->name;
 748   $page->export_type = EXPORT_IN_DATABASE;
 749   $page->type = t('Normal');
 750   $cache->subtask = page_manager_page_build_subtask($cache->task, $page);
 751
 752   if (isset($cache->handlers)) {
 753     foreach($cache->handlers as $id => $handler) {
 754       $cache->handler_info[$id]['changed'] = PAGE_MANAGER_CHANGED_DELETED;
 755     }
 756   }
 757   else {
 758     $cache->handlers = array();
 759     $cache->handler_info = array();
 760   }
 761
 762   if (!empty($page->default_handlers)) {
 763     foreach ($page->default_handlers as $id => $handler) {
 764       page_manager_handler_add_to_page($cache, $handler);
 765     }
 766   }
 767
 768   $cache->locked = FALSE;
 769   $cache->changed = TRUE;
 770 }
 771
 772 /**
 773  * Callback to determine if a page is accessible.
 774  *
 775  * @param $task
 776  *   The task plugin.
 777  * @param $subtask_id
 778  *   The subtask id
 779  * @param $contexts
 780  *   The contexts loaded for the task.
 781  * @return
 782  *   TRUE if the current user can access the page.
 783  */
 784 function page_manager_page_access_check($task, $subtask_id, $contexts) {
 785   $page = page_manager_page_load($subtask_id);
 786   return ctools_access($page->access, $contexts);
 787 }