Views: views_handler_field_upload

views_handler::accept_exposed_input ( $ input ) [inherited]

Take input from exposed filters and assign to this handler, if necessary.

Reimplemented in views_handler_filter, views_handler_filter_date, views_handler_filter_in_operator, views_handler_filter_numeric, views_handler_filter_term_node_tid, and views_handler_filter_user_name.

Definition at line 450 of file handlers.inc.

00450 { return TRUE; }

views_handler::access ( ) [inherited]

Check whether current user has access to this handler.

Returns:: boolean

Reimplemented in views_handler_field_node_revision_link_delete, views_handler_field_node_revision_link_revert, views_handler_field_user_link, views_handler_field_user_link_delete, and views_handler_field_user_link_edit.

Definition at line 357 of file handlers.inc.

Referenced by views_handler_argument::default_argument_form(), views_handler_sort_random::options_form(), views_handler_argument::options_form(), views_handler_field_user_language::render_link(), and views_handler_field_user::render_link().

00357                     {
00358     if (isset($this->definition['access callback']) && function_exists($this->definition['access callback'])) {
00359       if (isset($this->definition['access arguments']) && is_array($this->definition['access arguments'])) {
00360         return call_user_func_array($this->definition['access callback'], $this->definition['access arguments']);
00361       }
00362       return $this->definition['access callback']();
00363     }
00364 
00365     return TRUE;
00366   }

views_handler_field::add_additional_fields ( $ fields = NULL ) [inherited]

Add 'additional' fields to the query.

Parameters:

$fields

An array of fields. The key is an identifier used to later find the field alias used. The value is either a string in which case it's assumed to be a field on this handler's table; or it's an array in the form of

 array('table' => $tablename, 'field' => $fieldname)

Definition at line 80 of file views_handler_field.inc.

References views_handler_field::query().

00080                                                  {
00081     if (!isset($fields)) {
00082       // notice check
00083       if (empty($this->additional_fields)) {
00084         return;
00085       }
00086       $fields = $this->additional_fields;
00087     }
00088     if (!empty($fields) && is_array($fields)) {
00089       foreach ($fields as $identifier => $info) {
00090         if (is_array($info)) {
00091           if (isset($info['table'])) {
00092             $table_alias = $this->query->ensure_table($info['table'], $this->relationship);
00093           }
00094           else {
00095             $table_alias = $this->table_alias;
00096           }
00097           $this->aliases[$identifier] = $this->query->add_field($table_alias, $info['field']);
00098         }
00099         else {
00100           $this->aliases[$info] = $this->query->add_field($this->table_alias, $info);
00101         }
00102       }
00103     }
00104   }

views_handler_field_upload_fid::add_self_tokens	(	&$	tokens,
		$	item
	)

Add any special tokens this field might use for itself.

This method is intended to be overridden by items that generate fields as a list. For example, the field that displays all terms on a node might have tokens for the tid and the term.

By convention, tokens should follow the format of [token-subtoken] where token is the field ID and subtoken is the field. If the field ID is terms, then the tokens might be [terms-tid] and [terms-name].

Reimplemented from views_handler_field.

Definition at line 76 of file views_handler_field_upload_fid.inc.

References $item.

00076                                             {
00077     $tokens['[' . $this->options['id'] . '-fid' . ']'] = $item['fid'];
00078     $tokens['[' . $this->options['id'] . '-name' . ']'] = $item['filename'];
00079     $tokens['[' . $this->options['id'] . '-type' . ']'] = $item['filemime'];
00080     $tokens['[' . $this->options['id'] . '-description' . ']'] = $item['description'];
00081     $tokens['[' . $this->options['id'] . '-path' . ']'] = $item['filepath'];
00082     $tokens['[' . $this->options['id'] . '-size' . ']'] = $item['filesize'];
00083   }

views_handler_field::admin_summary ( ) [inherited]

Provide extra data to the administration form.

Reimplemented from views_handler.

Definition at line 411 of file views_handler_field.inc.

References views_handler_field::label().

00411                            {
00412     return $this->label();
00413   }

views_handler_field::advanced_render ( $ values ) [inherited]

Render a field using advanced settings.

This renders a field normally, then decides if render-as-link and text-replacement rendering is necessary.

Definition at line 443 of file views_handler_field.inc.

References $item, and $items.

00443                                     {
00444     if ($this->allow_advanced_render() && method_exists($this, 'render_item')) {
00445       $raw_items = $this->get_items($values);
00446     }
00447     else {
00448       $this->last_render = $value = $this->render($values);
00449       $this->original_value = $value;
00450     }
00451 
00452     if ($this->allow_advanced_render()) {
00453       $tokens = NULL;
00454       if (method_exists($this, 'render_item')) {
00455         $items = array();
00456         foreach ($raw_items as $count => $item) {
00457           $this->last_render = $this->render_item($count, $item);
00458           $this->original_value = $this->last_render;
00459 
00460           $alter = $item + $this->options['alter'];
00461           $items[] = $this->render_text($alter);       
00462         }
00463 
00464         $value = $this->render_items($items);
00465       }
00466       else {
00467         $value = $this->render_text($this->options['alter']);
00468       }
00469 
00470       // This happens here so that render_as_link can get the unaltered value of
00471       // this field as a token rather than the altered value.
00472       $this->last_render = $value;
00473     }
00474 
00475     if (empty($this->last_render)) {
00476       if ($this->last_render !== 0 || !empty($this->options['empty_zero'])) {
00477         $this->last_render = $this->options['empty'];
00478       }
00479     }
00480 
00481     return $this->last_render;
00482   }

views_handler_field_prerender_list::allow_advanced_render ( ) [inherited]

Determine if advanced rendering is allowed.

By default, advanced rendering will NOT be allowed if the class inheriting from this does not implement a 'render_items' method.

Reimplemented from views_handler_field.

Definition at line 107 of file views_handler_field_prerender_list.inc.

00107                                    {
00108     // Note that the advanced render bits also use the presence of
00109     // this method to determine if it needs to render items as a list.
00110     return method_exists($this, 'render_item');
00111   }

views_handler::broken ( ) [inherited]

Determine if the handler is considered 'broken', meaning it's a a placeholder used when a handler can't be found.

Reimplemented in views_handler_argument_broken, views_handler_field_broken, views_handler_filter_broken, views_handler_relationship_broken, and views_handler_sort_broken.

Definition at line 497 of file handlers.inc.

00497 { }

views_handler::can_expose ( ) [inherited]

Determine if a handler can be exposed.

Reimplemented in views_handler_filter, views_handler_filter_node_access, views_handler_filter_node_tnid, and views_handler_filter_node_tnid_child.

Definition at line 350 of file handlers.inc.

00350 { return FALSE; }

views_handler_field::click_sort ( $ order ) [inherited]

Called to determine what to tell the clicksorter.

Reimplemented in views_handler_field_search_score.

Definition at line 109 of file views_handler_field.inc.

References views_handler_field::query().

00109                               {
00110     $this->query->add_orderby($this->table, $this->field, $order, $this->field_alias);
00111   }

views_handler_field::click_sortable ( ) [inherited]

Determine if this field is click sortable.

Definition at line 116 of file views_handler_field.inc.

00116                             {
00117     return !empty($this->definition['click sortable']);
00118   }

views_handler_field_upload_fid::construct ( )

Construct a new field handler.

Reimplemented from views_handler_field.

Definition at line 7 of file views_handler_field_upload_fid.inc.

00007                        {
00008     parent::construct();
00009   }

views_handler_field_upload_fid::document_self_tokens ( &$ tokens )

Document any special tokens this field might use for itself.

See also:: add_self_tokens() for details.

Reimplemented from views_handler_field.

Definition at line 67 of file views_handler_field_upload_fid.inc.

00067                                           {
00068     $tokens['[' . $this->options['id'] . '-fid' . ']'] = t('The file ID for the file.');
00069     $tokens['[' . $this->options['id'] . '-name' . ']'] = t('The name of the attached file.');
00070     $tokens['[' . $this->options['id'] . '-type' . ']'] = t('The MIME type of the attached file.');
00071     $tokens['[' . $this->options['id'] . '-description' . ']'] = t('The name of the attached file.');
00072     $tokens['[' . $this->options['id'] . '-path' . ']'] = t('The path of the attached file.');
00073     $tokens['[' . $this->options['id'] . '-size' . ']'] = t('The size of the attached file.');
00074   }

views_handler_field::element_type ( ) [inherited]

Return DIV or SPAN based upon the field's element type.

Reimplemented in views_handler_field_markup, and views_handler_field_user_picture.

Definition at line 133 of file views_handler_field.inc.

00133                           {
00134     if (isset($this->definition['element type'])) {
00135       return $this->definition['element type'];
00136     }
00137 
00138     return 'span';
00139   }

views_handler::ensure_my_table ( ) [inherited]

Ensure the main table for this handler is in the query.

This is used a lot.

Reimplemented in views_handler_argument_broken, views_handler_argument_many_to_one, views_handler_field_broken, views_handler_filter_broken, views_handler_filter_many_to_one, views_handler_relationship_broken, and views_handler_sort_broken.

Definition at line 417 of file handlers.inc.

References views_handler::query().

00417                              {
00418     if (!isset($this->table_alias)) {
00419       if (!method_exists($this->query, 'ensure_table')) { vpr_trace(); exit; }
00420       $this->table_alias = $this->query->ensure_table($this->table, $this->relationship);
00421     }
00422     return $this->table_alias;
00423   }

views_handler::expose_options ( ) [inherited]

Set new exposed option defaults when exposed setting is flipped on.

Reimplemented in views_handler_filter, views_handler_filter_boolean_operator, and views_handler_filter_in_operator.

Definition at line 320 of file handlers.inc.

00320 { }

views_handler::exposed_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Render our chunk of the exposed filter form when selecting.

Reimplemented in views_handler_filter, and views_handler_filter_search.

Definition at line 324 of file handlers.inc.

00324 { }

views_handler::exposed_info ( ) [inherited]

Get information about the exposed form for the form renderer.

Returns:

An array with the following keys:

operator: The $form key of the operator. Set to NULL if no operator.
value: The $form key of the value. Set to NULL if no value.
label: The label to use for this piece.

Reimplemented in views_handler_filter.

Definition at line 345 of file handlers.inc.

00345 { }

views_handler::exposed_submit	(	&$	form,
		&$	form_state
	)			`[inherited]`

Submit the exposed filter form.

Definition at line 334 of file handlers.inc.

00334 { }

views_handler::exposed_validate	(	&$	form,
		&$	form_state
	)			`[inherited]`

Validate the exposed filter form.

Reimplemented in views_handler_filter_date, views_handler_filter_term_node_tid, and views_handler_filter_user_name.

Definition at line 329 of file handlers.inc.

00329 { }

views_handler::extra_options ( &$ option ) [inherited]

Provide defaults for the handler.

Definition at line 298 of file handlers.inc.

00298 { }

views_handler::extra_options_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Provide a form for setting options.

Reimplemented in views_handler_filter_term_node_tid, and views_handler_filter_term_node_tid_depth.

Definition at line 303 of file handlers.inc.

00303 { }

views_handler::extra_options_submit	(	$	form,
		&$	form_state
	)			`[inherited]`

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Definition at line 314 of file handlers.inc.

00314 { }

views_handler::extra_options_validate	(	$	form,
		&$	form_state
	)			`[inherited]`

Validate the options form.

Definition at line 308 of file handlers.inc.

00308 { }

views_handler_field_prerender_list::get_items ( $ values ) [inherited]

Return an array of items for the field.

Items should be stored in the result array, if possible, as an array with 'value' as the actual displayable value of the item, plus any items that might be found in the 'alter' options array for creating links, such as 'path', 'fragment', 'query' etc, such a thing is to be made. Additionally, items that might be turned into tokens should also be in this array.

Definition at line 92 of file views_handler_field_prerender_list.inc.

00092                               {
00093     $field = $values->{$this->field_alias};
00094     if (!empty($this->items[$field])) {
00095       return $this->items[$field];
00096     }
00097     
00098     return array();
00099   }

views_handler::get_join ( ) [inherited]

Get the join object that should be used for this handler.

This method isn't used a great deal, but it's very handy for easily getting the join if it is necessary to make some changes to it, such as adding an 'extra'.

Definition at line 464 of file handlers.inc.

References views_handler::query(), and views_get_table_join().

Referenced by views_handler_argument_many_to_one::summary_query().

00464                       {
00465     // get the join from this table that links back to the base table.
00466     // Determine the primary table to seek
00467     if (empty($this->query->relationships[$this->relationship])) {
00468       $base_table = $this->query->base_table;
00469     }
00470     else {
00471       $base_table = $this->query->relationships[$this->relationship]['base'];
00472     }
00473 
00474     $join = views_get_table_join($this->table, $base_table);
00475     if ($join) {
00476       return drupal_clone($join);
00477     }
00478   }

views_handler_field::get_render_tokens ( $ item ) [inherited]

Get the 'render' tokens to use for advanced rendering.

This runs through all of the fields and arguments that are available and gets their values. This will then be used in one giant str_replace().

Definition at line 642 of file views_handler_field.inc.

References $field, and $item.

00642                                     {
00643     $tokens = array();
00644     if (!empty($this->view->build_info['substitutions'])) {
00645       $tokens = $this->view->build_info['substitutions'];
00646     }
00647     $count = 0;
00648     foreach ($this->view->display_handler->get_handlers('argument') as $arg => $handler) {
00649       $token = '%' . ++$count;
00650       if (!isset($tokens[$token])) {
00651         $tokens[$token] = '';
00652       }
00653 
00654       $tokens['!' . $count] = isset($this->view->args[$count - 1]) ? check_plain($this->view->args[$count - 1]) : '';
00655     }
00656 
00657     // Now add replacements for our fields.
00658     foreach ($this->view->display_handler->get_handlers('field') as $field => $handler) {
00659       if (isset($handler->last_render)) {
00660         $tokens["[$field]"] = $handler->last_render;
00661       }
00662       else {
00663         $tokens["[$field]"] = '';
00664       }
00665       // We only use fields up to (and including) this one.
00666       if ($field == $this->options['id']) {
00667         break;
00668       }
00669 
00670       $this->add_self_tokens($tokens, $item);
00671     }
00672 
00673     return $tokens;
00674   }

views_handler::has_extra_options ( ) [inherited]

If a handler has 'extra options' it will get a little settings widget and another form called extra_options.

Reimplemented in views_handler_filter_term_node_tid.

Definition at line 293 of file handlers.inc.

00293 { return FALSE; }

views_handler_field::init	(	&$	view,
		$	options
	)			`[inherited]`

init the handler with necessary data.

Parameters:

	$view	The $view object this handler is attached to.
	$options	The item from the database; the actual contents of this will vary based upon the type of handler.

Reimplemented from views_handler.

Reimplemented in views_handler_field_node_new_comments, views_handler_field_history_user_timestamp, and views_handler_field_term_node_tid.

Definition at line 51 of file views_handler_field.inc.

References views_object::$options, and views_object::options().

00051                                   {
00052     parent::init($view, $options);
00053 
00054     $this->options += array(
00055       'exclude' => FALSE,
00056     );
00057   }

views_handler::is_exposed ( ) [inherited]

Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.

Returns:: TRUE/FALSE

Definition at line 443 of file handlers.inc.

References views_object::options().

00443                         {
00444     return !empty($this->options['exposed']);
00445   }

views_handler_field::label ( ) [inherited]

Get this field's label.

Definition at line 123 of file views_handler_field.inc.

References views_object::options().

Referenced by views_handler_field::admin_summary(), views_handler_field::option_definition(), views_handler_field_contact_link::options_form(), and views_handler_field::options_form().

00123                    {
00124     if (!isset($this->options['label'])) {
00125       return '';
00126     }
00127     return $this->options['label'];
00128   }

views_handler::needs_style_plugin ( ) [inherited]

Determine if the argument needs a style plugin.

Returns:: TRUE/FALSE

Reimplemented in views_handler_argument.

Definition at line 435 of file handlers.inc.

00435 { return FALSE; }

views_handler_field_upload_fid::option_definition ( )

Information about options for all kinds of purposes will be held here.

 'option_name' => array(
  - 'default' => default value,
  - 'translatable' => TRUE/FALSE (wrap in t() on export if true),
  - 'contains' => array of items this contains, with its own defaults, etc.
      If contains is set, the default will be ignored and assumed to
      be array()

  ),

Each option may have any of the following functions:

export_option_OPTIONNAME -- Special export handling if necessary.
translate_option_OPTIONNAME -- Special handling for translating data within the option, if necessary.

Reimplemented from views_handler_field_prerender_list.

Definition at line 11 of file views_handler_field_upload_fid.inc.

References views_object::$options.

00011                                {
00012     $options = parent::option_definition();
00013     $options['link_to_file'] = array('default' => FALSE);
00014     $options['only_listed'] = array('default' => FALSE);
00015     return $options;
00016   }

views_object::options ( ) [inherited]

Set default options on this object.

Called by the constructor in a complex chain to deal with backward compatibility.

Definition at line 46 of file base.inc.

00046 { }

views_handler_field_upload_fid::options_form	(	&$	form,
		&$	form_state
	)

Default options form that provides the label widget that all fields should have.

Reimplemented from views_handler_field_prerender_list.

Definition at line 18 of file views_handler_field_upload_fid.inc.

References views_object::options().

00018                                               {
00019     parent::options_form($form, $form_state);
00020     $form['link_to_file'] = array(
00021       '#title' => t('Link this field to download the file'),
00022       '#type' => 'checkbox',
00023       '#default_value' => !empty($this->options['link_to_file']),
00024     );
00025 
00026     $form['only_listed'] = array(
00027       '#title' => t('Only show "listed" file attachments'),
00028       '#type' => 'checkbox',
00029       '#default_value' => !empty($this->options['only_listed']),
00030     );
00031   }

views_handler::options_submit	(	$	form,
		&$	form_state
	)			`[inherited]`

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Definition at line 287 of file handlers.inc.

00287 { }

views_handler::options_validate	(	$	form,
		&$	form_state
	)			`[inherited]`

Validate the options form.

Definition at line 281 of file handlers.inc.

00281 { }

views_handler::pre_query ( ) [inherited]

Run before the view is built.

This gives all the handlers some time to set up before any handler has been fully run.

Reimplemented in views_handler_argument_term_node_tid_depth_modifier.

Definition at line 374 of file handlers.inc.

00374 { }

views_handler_field_upload_fid::pre_render ( $ values )

Run before any fields are rendered.

This gives the handlers some time to set up before any handler has been rendered.

Parameters:

$values

An array of all objects returned from the query.

Reimplemented from views_handler_field.

Definition at line 33 of file views_handler_field_upload_fid.inc.

00033                                {
00034     $vids = array();
00035     $this->items = array();
00036 
00037     foreach ($values as $result) {
00038       $vids[] = $result->{$this->field_alias};
00039     }
00040 
00041     if ($vids) {
00042       // Support "only listed files" option.
00043       $where = '';
00044       if (!empty($this->options['only_listed'])) {
00045         $where = " AND u.list <> 0";
00046       }
00047       $result = db_query("SELECT u.vid, u.fid, f.filename, f.filepath, f.filesize, f.filemime, u.description FROM {upload} u LEFT JOIN {files} f ON f.fid = u.fid WHERE u.vid IN (" . implode(', ', $vids) . ")$where ORDER BY u.weight");
00048       while ($file = db_fetch_array($result)) {
00049         $file['filename'] = check_plain($file['filename']);
00050         $file['filemime'] = check_plain($file['filemime']);
00051         $file['description'] = check_plain($file['description']);
00052         $file['filesize'] = format_size($file['filesize']);
00053         $file['filepath'] = file_create_url($file['filepath']);
00054         if (!empty($this->options['link_to_file']) ) {
00055           $file['make_link'] = TRUE;
00056           $file['path'] = $file['filepath'];
00057         }
00058         $this->items[$file['vid']][$file['fid']] = $file;
00059       }
00060     }
00061   }

views_handler_field::query ( ) [inherited]

Called to add the field to a query.

Reimplemented from views_handler.

Definition at line 62 of file views_handler_field.inc.

References views_handler_field::add_additional_fields(), and views_handler::ensure_my_table().

Referenced by views_handler_field::add_additional_fields(), and views_handler_field::click_sort().

00062                    {
00063     $this->ensure_my_table();
00064     // Add the field.
00065     $this->field_alias = $this->query->add_field($this->table_alias, $this->real_field);
00066 
00067     $this->add_additional_fields();
00068   }

views_handler_field_prerender_list::render ( $ values ) [inherited]

Render the field.

This function is deprecated, but left in for older systems that have not yet or won't update their prerender list fields. If a render_item method exists, this will not get used by advanced_render.

Reimplemented from views_handler_field.

Definition at line 53 of file views_handler_field_prerender_list.inc.

References $field.

00053                            {
00054     $field = $values->{$this->field_alias};
00055     if (!empty($this->items[$field])) {
00056       if ($this->options['type'] == 'separator') {
00057         return implode(check_plain($this->options['separator']), $this->items[$field]);
00058       }
00059       else {
00060         return theme('item_list', $this->items[$field], NULL, $this->options['type']);
00061       }
00062     }
00063   }

views_handler_field::render_altered	(	$	alter,
		$	tokens
	)			`[inherited]`

Render this field as altered text, from a fieldset set by the user.

Definition at line 518 of file views_handler_field.inc.

00518                                            {
00519     // Filter this right away as our substitutions are already sanitized.
00520     $value = filter_xss_admin($alter['text']);
00521     $value = strtr($value, $tokens);
00522 
00523     return $value;
00524   }

views_handler_field::render_as_link	(	$	alter,
		$	text,
		$	tokens
	)			`[inherited]`

Render this field as a link, with the info from a fieldset set by the user.

Definition at line 567 of file views_handler_field.inc.

References $class.

00567                                                   {
00568     $value = '';
00569 
00570     if (!empty($alter['prefix'])) {
00571       $value .= filter_xss_admin(strtr($alter['prefix'], $tokens));
00572     }
00573 
00574     $options = array(
00575       'html' => 'true',
00576     );
00577 
00578     // $path will be run through check_url() by l() so we do not need to
00579     // sanitize it ourselves.
00580     $path = $alter['path'];
00581 
00582     // Use strip tags as there should never be HTML in the path.
00583     // However, we need to preserve special characters like " that
00584     // were removed by check_plain().
00585     $path = strip_tags(html_entity_decode(strtr($path, $tokens)));
00586 
00587     // Parse the URL and move any query and fragment parameters out of the path.
00588     $url = parse_url($path);
00589     if (isset($url['query'])) {
00590       $path = strtr($path, array('?' . $url['query'] => ''));
00591       $options['query'] = $url['query'];
00592     }
00593     if (isset($url['fragment'])) {
00594       $path = strtr($path, array('#' . $url['fragment'] => ''));
00595       $options['fragment'] = $url['fragment'];
00596     }
00597 
00598     $alt = strtr($alter['alt'], $tokens);
00599     // Set the title attribute of the link only if it improves accessibility
00600     if ($alt && $alt != $text) {
00601       $options['attributes']['title'] = $alt;
00602     }
00603 
00604     $class = strtr($alter['link_class'], $tokens);
00605     if ($class) {
00606       $options['attributes']['class'] = $class;
00607     }
00608 
00609     $target = check_plain(trim($alter['target']));
00610     if (!empty($target)) {
00611       $options['attributes']['target'] = $target;
00612     }
00613 
00614     // If the query and fragment were programatically assigned overwrite any
00615     // parsed values.
00616     if (isset($alter['query'])) {
00617       $options['query'] = strtr($alter['query'], $tokens);
00618     }
00619     if (isset($alter['fragment'])) {
00620       $options['fragment'] = strtr($alter['fragment'], $tokens);
00621     }
00622     if (isset($this->options['alter']['language'])) {
00623       $options['language'] = $this->options['alter']['language'];
00624     }
00625 
00626     $value .= l($text, $path, $options);
00627 
00628     if (!empty($alter['suffix'])) {
00629       $value .= filter_xss_admin(strtr($alter['suffix'], $tokens));
00630     }
00631 
00632     return $value;
00633   }

views_handler_field_prerender_list::render_items ( $ items ) [inherited]

Render all items in this field together.

When using advanced render, each possible item in the list is rendered individually. Then the items are all pasted together.

Definition at line 71 of file views_handler_field_prerender_list.inc.

References $items.

00071                                 {
00072     if (!empty($items)) {
00073       if ($this->options['type'] == 'separator') {
00074         return implode(check_plain($this->options['separator']), $items);
00075       }
00076       else {
00077         return theme('item_list', $items, NULL, $this->options['type']);
00078       }
00079     }
00080   }

views_handler_field::render_text ( $ alter ) [inherited]

Perform an advanced text render for the item.

This is separated out as some fields may render lists, and this allows each item to be handled individually.

Definition at line 490 of file views_handler_field.inc.

00490                                {
00491     $value = trim($this->last_render);
00492     if ($this->options['hide_empty'] && empty($value) && ($value !== 0 || $this->options['empty_zero'])) {
00493       return '';
00494     }
00495 
00496     if (!empty($alter['alter_text']) && $alter['text'] !== '') {
00497       $tokens = $this->get_render_tokens($alter);
00498       $value = $this->render_altered($alter, $tokens);
00499     }
00500 
00501     if (!empty($alter['trim']) && !empty($alter['max_length'])) {
00502       $value = $this->render_trim_text($alter, $value);
00503     }
00504 
00505     if (!empty($alter['make_link']) && !empty($alter['path'])) {
00506       if (!isset($tokens)) {
00507        $tokens = $this->get_render_tokens($alter);
00508       }
00509       $value = $this->render_as_link($alter, $value, $tokens);
00510     }
00511 
00512     return $value;
00513   }

views_handler_field::render_trim_text	(	$	alter,
		$	value
	)			`[inherited]`

Trim the field down to the specified length.

Definition at line 529 of file views_handler_field.inc.

00529                                             {
00530     if (!empty($alter['strip_tags'])) {
00531       $value = strip_tags($value);
00532       // NOTE: It's possible that some external fields might override the
00533       // element type so if someone from, say, CCK runs into a bug here,
00534       // this may be why =)
00535       $this->definition['element type'] = 'span';
00536     }
00537 
00538     if (drupal_strlen($value) <= $alter['max_length']) {
00539       return $value;
00540     }
00541 
00542     $value = drupal_substr($value, 0, $alter['max_length']);
00543 
00544     if (!empty($alter['word_boundary'])) {
00545       if (preg_match("/(.*)\b.+/us", $value, $matches)) {
00546         $value = $matches[1];
00547       }
00548     }
00549     // Remove scraps of HTML entities from the end of a strings
00550     $value = rtrim(preg_replace('/(?:<(?!.+>)|&(?!.+;)).*$/us', '', $value));
00551 
00552     if (!empty($alter['ellipsis'])) {
00553       $value .= '...';
00554     }
00555 
00556     if (!empty($alter['html'])) {
00557       $value = _filter_htmlcorrector($value);
00558     }
00559 
00560     return $value;
00561   }

views_object::set_default_options ( ) [inherited]

Set default options.

For backward compatibility, it sends the options array; this is a feature that will likely disappear at some point.

Definition at line 53 of file base.inc.

References views_object::_set_option_defaults(), views_object::option_definition(), and views_object::options().

Referenced by views_object::construct().

00053                                  {
00054     $this->_set_option_defaults($this->options, $this->option_definition());
00055 
00056     // Retained for complex defaults plus backward compatibility.
00057     $this->options($this->options);
00058   }

views_object::set_definition ( $ definition ) [inherited]

Let the handler know what its full definition is.

Definition at line 108 of file base.inc.

00108                                        {
00109     $this->definition = $definition;
00110     if (isset($definition['field'])) {
00111       $this->real_field = $definition['field'];
00112     }
00113   }

views_handler::set_relationship ( ) [inherited]

Called just prior to query(), this lets a handler set up any relationship it needs.

Definition at line 380 of file handlers.inc.

References views_object::options().

00380                               {
00381     // Ensure this gets set to something.
00382     $this->relationship = NULL;
00383 
00384     // Don't process non-existant relationships.
00385     if (empty($this->options['relationship']) || $this->options['relationship'] == 'none') {
00386       return;
00387     }
00388 
00389     $relationship = $this->options['relationship'];
00390 
00391     // Ignore missing/broken relationships.
00392     if (empty($this->view->relationship[$relationship])) {
00393       return;
00394     }
00395 
00396     // Check to see if the relationship has already processed. If not, then we
00397     // cannot process it.
00398     if (empty($this->view->relationship[$relationship]->alias)) {
00399       return;
00400     }
00401 
00402     // Finally!
00403     $this->relationship = $this->view->relationship[$relationship]->alias;
00404   }

views_handler::store_exposed_input	(	$	input,
		$	status
	)			`[inherited]`

If set to remember exposed input in the session, store it there.

Reimplemented in views_handler_filter.

Definition at line 455 of file handlers.inc.

00455 { return TRUE; }

views_handler_field::theme ( $ values ) [inherited]

Call out to the theme() function, which probably just calls render() but allows sites to override output fairly easily.

Definition at line 700 of file views_handler_field.inc.

Referenced by views_handler_field::options_form(), and views_handler_field_user_name::render_link().

00700                           {
00701     return theme($this->theme_functions(), $this->view, $this, $values);
00702   }

views_handler::ui_name ( $ short = FALSE ) [inherited]

Return a string representing this handler's name in the UI.

Reimplemented in views_handler_argument_broken, views_handler_field_broken, views_handler_filter_broken, views_handler_relationship_broken, and views_handler_sort_broken.

Definition at line 268 of file handlers.inc.

References $title.

Referenced by views_handler_filter::expose_options(), views_handler_relationship::label(), and views_handler_field::options_form().

00268                                    {
00269     $title = ($short && isset($this->definition['title short'])) ? $this->definition['title short'] : $this->definition['title'];
00270     return t('!group: !title', array('!group' => $this->definition['group'], '!title' => $title));
00271   }

views_object::unpack_options	(	&$	storage,
		$	options,
		$	definition = `NULL`
	)			`[inherited]`

Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.

Definition at line 79 of file base.inc.

References views_object::$options, and views_object::option_definition().

Referenced by views_plugin_style::init(), views_plugin_row::init(), views_plugin_display::init(), and views_handler::init().

00079                                                                    {
00080     if (!is_array($options)) {
00081       return;
00082     }
00083 
00084     if (!isset($definition)) {
00085       $definition = $this->option_definition();
00086     }
00087 
00088     foreach ($options as $key => $value) {
00089       if (is_array($value)) {
00090         if (!isset($storage[$key]) || !is_array($storage[$key])) {
00091           $storage[$key] = array();
00092         }
00093 
00094         $this->unpack_options($storage[$key], $value, isset($definition[$key]['contains']) ? $definition[$key]['contains'] : array());
00095       }
00096       else if (!empty($definition[$key]['translatable']) && !empty($value)) {
00097         $storage[$key] = t($value);
00098       }
00099       else {
00100         $storage[$key] = $value;
00101       }
00102     }
00103   }

views_handler::validate ( ) [inherited]

Validates the handler against the complete View.

This is called when the complete View is being validated. For validating the handler options form use options_validate().

See also:: views_handler::options_validate()

Returns:: Empty array if the handler is valid; an array of error strings if it is not.

Definition at line 491 of file handlers.inc.

Referenced by views_handler_argument::options_form().

00491 { return array(); }

views_object::$options = array() [inherited]

Except for displays, options for the object will be held here.

Definition at line 16 of file base.inc.


Public Member Functions
	construct ()
	Construct a new field handler.
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	options_form (&$form, &$form_state)
	Default options form that provides the label widget that all fields should have.
	pre_render ($values)
	Run before any fields are rendered.
	render_item ($count, $item)
	document_self_tokens (&$tokens)
	Document any special tokens this field might use for itself.
	add_self_tokens (&$tokens, $item)
	Add any special tokens this field might use for itself.
	render ($values)
	Render the field.
	render_items ($items)
	Render all items in this field together.
	get_items ($values)
	Return an array of items for the field.
	allow_advanced_render ()
	Determine if advanced rendering is allowed.
	init (&$view, $options)
	init the handler with necessary data.
	query ()
	Called to add the field to a query.
	add_additional_fields ($fields=NULL)
	Add 'additional' fields to the query.
	click_sort ($order)
	Called to determine what to tell the clicksorter.
	click_sortable ()
	Determine if this field is click sortable.
	label ()
	Get this field's label.
	element_type ()
	Return DIV or SPAN based upon the field's element type.
	admin_summary ()
	Provide extra data to the administration form.
	advanced_render ($values)
	Render a field using advanced settings.
	render_text ($alter)
	Perform an advanced text render for the item.
	render_altered ($alter, $tokens)
	Render this field as altered text, from a fieldset set by the user.
	render_trim_text ($alter, $value)
	Trim the field down to the specified length.
	render_as_link ($alter, $text, $tokens)
	Render this field as a link, with the info from a fieldset set by the user.
	get_render_tokens ($item)
	Get the 'render' tokens to use for advanced rendering.
	theme ($values)
	Call out to the theme() function, which probably just calls render() but allows sites to override output fairly easily.
	theme_functions ()
	ui_name ($short=FALSE)
	Return a string representing this handler's name in the UI.
	options_validate ($form, &$form_state)
	Validate the options form.
	options_submit ($form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	has_extra_options ()
	If a handler has 'extra options' it will get a little settings widget and another form called extra_options.
	extra_options (&$option)
	Provide defaults for the handler.
	extra_options_form (&$form, &$form_state)
	Provide a form for setting options.
	extra_options_validate ($form, &$form_state)
	Validate the options form.
	extra_options_submit ($form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	expose_options ()
	Set new exposed option defaults when exposed setting is flipped on.
	exposed_form (&$form, &$form_state)
	Render our chunk of the exposed filter form when selecting.
	exposed_validate (&$form, &$form_state)
	Validate the exposed filter form.
	exposed_submit (&$form, &$form_state)
	Submit the exposed filter form.
	exposed_info ()
	Get information about the exposed form for the form renderer.
	can_expose ()
	Determine if a handler can be exposed.
	access ()
	Check whether current user has access to this handler.
	pre_query ()
	Run before the view is built.
	set_relationship ()
	Called just prior to query(), this lets a handler set up any relationship it needs.
	ensure_my_table ()
	Ensure the main table for this handler is in the query.
	needs_style_plugin ()
	Determine if the argument needs a style plugin.
	is_exposed ()
	Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.
	accept_exposed_input ($input)
	Take input from exposed filters and assign to this handler, if necessary.
	store_exposed_input ($input, $status)
	If set to remember exposed input in the session, store it there.
	get_join ()
	Get the join object that should be used for this handler.
	validate ()
	Validates the handler against the complete View.
	broken ()
	Determine if the handler is considered 'broken', meaning it's a a placeholder used when a handler can't be found.
	options ()
	Set default options on this object.
	set_default_options ()
	Set default options.
	_set_option_defaults (&$storage, $options, $level=0)
	unpack_options (&$storage, $options, $definition=NULL)
	Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.
	set_definition ($definition)
	Let the handler know what its full definition is.
	destroy ()
Public Attributes
	$field_alias = 'unknown'
	$aliases = array()
	$options = array()
	Except for displays, options for the object will be held here.

views_handler_field_upload_fid Class Reference

Detailed Description

Public Member Functions

Public Attributes

Member Function Documentation

Member Data Documentation