1 | <?php |
---|
2 | // $Id: editablefields.module,v 1.3.2.17.2.10 2010/01/18 08:48:10 markfoodyburton Exp $ |
---|
3 | |
---|
4 | /** |
---|
5 | * @file |
---|
6 | * Editable fields module. |
---|
7 | */ |
---|
8 | |
---|
9 | /** |
---|
10 | * Implementation of hook_menu(). |
---|
11 | */ |
---|
12 | function editablefields_menu() { |
---|
13 | global $user; |
---|
14 | $items = array(); |
---|
15 | |
---|
16 | // Admin pages: |
---|
17 | $items['editablefields_view'] = array( |
---|
18 | 'page callback' => 'editablefields_view', |
---|
19 | 'access arguments' => array('access content'), |
---|
20 | 'type' => MENU_CALLBACK, |
---|
21 | 'title' => 'ajax view', |
---|
22 | ); |
---|
23 | $items['editablefields_html'] = array( |
---|
24 | 'page callback' => 'editablefields_html', |
---|
25 | 'access arguments' => array('access content'), |
---|
26 | 'type' => MENU_CALLBACK, |
---|
27 | 'title' => 'ajax form', |
---|
28 | ); |
---|
29 | $items['editablefields_submit'] = array( |
---|
30 | 'page callback' => 'editablefields_submit', |
---|
31 | 'access arguments' => array('access content'), |
---|
32 | 'type' => MENU_CALLBACK, |
---|
33 | 'title' => 'ajax submit', |
---|
34 | ); |
---|
35 | |
---|
36 | return $items; |
---|
37 | } |
---|
38 | |
---|
39 | /** |
---|
40 | * Implementation of hook_theme(). |
---|
41 | */ |
---|
42 | function editablefields_theme() { |
---|
43 | return array( |
---|
44 | 'editablefields_formatter_editable' => array( |
---|
45 | 'arguments' => array('element' => NULL), |
---|
46 | 'function' => 'theme_editablefields_formatter_editable', |
---|
47 | ), |
---|
48 | 'editablefields_formatter_editable_html' => array( |
---|
49 | 'arguments' => array('element' => NULL), |
---|
50 | 'function' => 'theme_editablefields_formatter_editable', |
---|
51 | ), |
---|
52 | 'editablefields_formatter_clicktoedit' => array( |
---|
53 | 'arguments' => array('element' => NULL), |
---|
54 | 'function' => 'theme_editablefields_formatter_editable', |
---|
55 | ), |
---|
56 | ); |
---|
57 | } |
---|
58 | |
---|
59 | /** |
---|
60 | * Implementation of hook_field_formatter_info(). |
---|
61 | */ |
---|
62 | function editablefields_field_formatter_info() { |
---|
63 | return array( |
---|
64 | 'editable' => array( |
---|
65 | 'label' => t('Editable (Ajax)'), |
---|
66 | 'field types' => array_keys(_content_field_types()), |
---|
67 | ), |
---|
68 | 'editable_html' => array( |
---|
69 | 'label' => t('Editable (HTML)'), |
---|
70 | 'field types' => array_keys(_content_field_types()), |
---|
71 | ), |
---|
72 | 'clicktoedit' => array( |
---|
73 | 'label' => t('Click to Edit'), |
---|
74 | 'field types' => array_keys(_content_field_types()), |
---|
75 | ), |
---|
76 | ); |
---|
77 | } |
---|
78 | |
---|
79 | /** |
---|
80 | * Theme the editable field. |
---|
81 | */ |
---|
82 | function theme_editablefields_formatter_editable($element) { |
---|
83 | static $js_ready; |
---|
84 | |
---|
85 | $field_name = $element['#field_name']; |
---|
86 | $field = content_fields($field_name); |
---|
87 | $node = $element['#node']; |
---|
88 | $delta = $element['#item']['#delta']; |
---|
89 | |
---|
90 | if (content_handle('widget', 'multiple values', $field) == CONTENT_HANDLE_CORE) { |
---|
91 | } |
---|
92 | |
---|
93 | // See if access to this form element is restricted, |
---|
94 | // if so, skip widget processing and just set the value. |
---|
95 | if (!node_access('update', $node) || !content_access('edit', $field)) { |
---|
96 | // can't edit |
---|
97 | $formatter_name = 'default'; |
---|
98 | if ($formatter = _content_get_formatter($formatter_name, $field['type'])) { |
---|
99 | $theme = $formatter['module'] . '_formatter_' . $formatter_name; |
---|
100 | return theme($theme, $element); |
---|
101 | } |
---|
102 | } |
---|
103 | else { |
---|
104 | $formatter_name = 'default'; |
---|
105 | if ($formatter = _content_get_formatter($formatter_name, $field['type'])) { |
---|
106 | if (!isset($js_ready)) { |
---|
107 | $js_ready = TRUE; |
---|
108 | drupal_add_js('misc/jquery.form.js'); |
---|
109 | drupal_add_js(drupal_get_path('module', 'editablefields') . '/editablefields.js'); |
---|
110 | drupal_add_css(drupal_get_path('module', 'editablefields') . '/editablefields.css'); |
---|
111 | |
---|
112 | $settings = array( |
---|
113 | 'url_html' => url('editablefields_html', array('absolute' => TRUE)), |
---|
114 | 'url_submit' => url('editablefields_submit', array('absolute' => TRUE)), |
---|
115 | 'url_view' => url('editablefields_view', array('absolute' => TRUE)), |
---|
116 | 'clicktoedit_message' => '<div class="editablefields_clicktoedit_message">'. t('[edit]') .'</div>', |
---|
117 | ); |
---|
118 | drupal_add_js(array('editablefields' => $settings), 'setting'); |
---|
119 | } |
---|
120 | $theme = $formatter['module'] . '_formatter_' . $formatter_name; |
---|
121 | $class = "editablefields"; |
---|
122 | if ($element['#formatter'] == 'clicktoedit') { |
---|
123 | $class .= " clicktoedit"; |
---|
124 | } |
---|
125 | elseif ($element['#formatter'] == 'editable_html') { |
---|
126 | $class .= " editablefields-html-load"; |
---|
127 | } |
---|
128 | // CORE handling shoudl have a div on each, |
---|
129 | // MODULE handling should have a div surounding all elements (treat it as |
---|
130 | // one field) (So, we'll arrainge for the JS to remove the rest!) |
---|
131 | if (content_handle('widget', 'multiple values', $field) != CONTENT_HANDLE_CORE) { |
---|
132 | if ($delta != 0) { |
---|
133 | $class = "editablefields editablefields_REMOVE"; |
---|
134 | } |
---|
135 | } |
---|
136 | |
---|
137 | $pre = '<div class="' . $class . '" nid="' . $node->nid . '" field="' . $field_name . '" delta="' . $delta . '">'; |
---|
138 | $post = '</div>'; |
---|
139 | |
---|
140 | if ($element['#formatter'] != 'editable_html') { |
---|
141 | return $pre . theme($theme, $element) . $post; |
---|
142 | } |
---|
143 | else { |
---|
144 | // $node seems to be incomplete, so we reload it |
---|
145 | $node = node_load($node->nid); |
---|
146 | return $pre . drupal_get_form('editablefields_form', $node, $field_name, $delta) . $post; |
---|
147 | } |
---|
148 | } |
---|
149 | } |
---|
150 | } |
---|
151 | |
---|
152 | /** |
---|
153 | * Implementation of hook_forms(). |
---|
154 | */ |
---|
155 | function editablefields_forms() { |
---|
156 | $forms = array(); |
---|
157 | $forms['editablefields_form'] = array( |
---|
158 | 'callback' => 'editablefields_form_builder', |
---|
159 | // 'callback arguments' => array('node', 'field_name'), |
---|
160 | ); |
---|
161 | return $forms; |
---|
162 | } |
---|
163 | |
---|
164 | /** |
---|
165 | * Form builder callback. |
---|
166 | */ |
---|
167 | function editablefields_form_builder(&$form_state, $node, $field_name, $delta) { |
---|
168 | $field = content_fields($field_name); |
---|
169 | |
---|
170 | $form = array('#node' => $node); |
---|
171 | // $form_state = array('values' => array($field['field_name'] => $default_value)); |
---|
172 | module_load_include('inc', 'content', 'includes/content.node_form'); |
---|
173 | $form['#field_info'] = array($field['field_name'] => $field); |
---|
174 | $form = content_field_form($form, $form_state, $field, $delta); |
---|
175 | |
---|
176 | unset($form[$field_name]['#title']); |
---|
177 | if (is_array($form[$field_name][0]) && !is_array($form[$field_name][1])) { |
---|
178 | unset($form[$field_name][0]['#title']); |
---|
179 | } |
---|
180 | |
---|
181 | $form['#field_info'] = array($field['field_name'] => $field); |
---|
182 | $form['#pre_render'] = array('_editablefields_pre_render'); |
---|
183 | |
---|
184 | return $form; |
---|
185 | } |
---|
186 | |
---|
187 | /** |
---|
188 | * Resizable Textarea has an issue with setting focus. |
---|
189 | * To circumvent this we have to set the forms fields #resizable field to FALSE. |
---|
190 | * We have to use pre_render because the here the field's #type is still textarea. |
---|
191 | * TODO Keep editable_HTML and editable_JAVA fields resizable, they don't have the focus issue. |
---|
192 | */ |
---|
193 | function _editablefields_pre_render(&$form) { |
---|
194 | if ($form['field_name'][0]['value']['#type'] == 'textarea') { |
---|
195 | $form['field_name'][0]['value']['#resizable'] = FALSE; |
---|
196 | } |
---|
197 | return $form; |
---|
198 | } |
---|
199 | /** |
---|
200 | * Menu callback: ajax view. |
---|
201 | */ |
---|
202 | function editablefields_view() { |
---|
203 | |
---|
204 | $nid = arg(1); |
---|
205 | $field_name = arg(2); |
---|
206 | $delta = arg(3); |
---|
207 | $node = node_load($nid); |
---|
208 | drupal_set_header('Content-Type: text; charset=utf-8'); |
---|
209 | // $html = node_view($node, FALSE, FALSE, FALSE); |
---|
210 | // this required traversing the entire node to get the field (and doesn't work |
---|
211 | // for checkboxes anyway) |
---|
212 | |
---|
213 | $field = content_fields($field_name, $node->type); |
---|
214 | |
---|
215 | $field['display_settings']['label']['format']='hidden'; |
---|
216 | // We have 2 reasonable choices here. We COULD use 'clicktoedit' and end up |
---|
217 | // with the same HTML - then we could strip that HTML down to remove the |
---|
218 | // surrounding 'click to edit' div (which we dont want, as we'll be replacing |
---|
219 | // the html inside one of those div's) |
---|
220 | // or we can simply use the 'defualt' formatter - which wont have the click to |
---|
221 | // edit inside it - and is hard coded into this module (for now) anyway! |
---|
222 | $field['display_settings']['full']['format']='default'; |
---|
223 | $html=content_view_field($field,$node); |
---|
224 | |
---|
225 | $messages = drupal_get_messages('status', TRUE); |
---|
226 | if (count($messages) > 0) { |
---|
227 | foreach ($messages as $type => $messages) { |
---|
228 | foreach ($messages as $message) { |
---|
229 | $output .= '<div class="messages ' . $type . '">' . $message . "</div>"; |
---|
230 | } |
---|
231 | } |
---|
232 | } |
---|
233 | |
---|
234 | $object = new stdClass(); |
---|
235 | $object->content = $output . $html.drupal_render($node->content[$field_name]); |
---|
236 | drupal_json($object); |
---|
237 | exit(); |
---|
238 | } |
---|
239 | |
---|
240 | /** |
---|
241 | * Menu callback: ajax form. |
---|
242 | */ |
---|
243 | function editablefields_html() { |
---|
244 | $nid = arg(1); |
---|
245 | $field_name = arg(2); |
---|
246 | $delta = arg(3); |
---|
247 | $node = node_load($nid); |
---|
248 | |
---|
249 | if (node_access('update', $node)) { |
---|
250 | // $html = _editablefields_create_form($node, $field_name); |
---|
251 | $html = drupal_get_form('editablefields_form', $node, $field_name, $delta); |
---|
252 | $object = new stdClass(); |
---|
253 | $object->content = $html; |
---|
254 | // Register the JavaScript callback for this module. |
---|
255 | $object->__callbacks = array(); |
---|
256 | // Allow other modules to extend the data returned. |
---|
257 | drupal_alter('ajax_data', $object, 'editablefields', $html); |
---|
258 | drupal_json($object); |
---|
259 | } |
---|
260 | else { |
---|
261 | drupal_not_found(); |
---|
262 | } |
---|
263 | exit(); |
---|
264 | } |
---|
265 | |
---|
266 | /** |
---|
267 | * Menu callback: ajax submit. |
---|
268 | */ |
---|
269 | function editablefields_submit() { |
---|
270 | $nid = $_POST['nid']; |
---|
271 | $field_name = $_POST['field']; |
---|
272 | $delta = $_POST['delta']; |
---|
273 | |
---|
274 | $node = node_load($nid); |
---|
275 | |
---|
276 | if (node_access('update', $node)) { |
---|
277 | |
---|
278 | if (!isset($_POST[$field_name])) { |
---|
279 | $_POST[$field_name] = array(); |
---|
280 | } |
---|
281 | |
---|
282 | $form_state = array('values' => $_POST); |
---|
283 | |
---|
284 | /* it seems that the serializer does not serialize e.g. un-checked |
---|
285 | * checkboxes. Leaving them as empty arrays. This FILTHY hack fills in the |
---|
286 | * array with 'something' so that when the form is executed, it fills in the |
---|
287 | * right value - I dislike this code - JMB */ |
---|
288 | if (is_array($node->{$field_name})) { |
---|
289 | if (content_handle('widget', 'multiple values', $field) == CONTENT_HANDLE_CORE) { |
---|
290 | if (empty($form_state['values'][$field_name])) { |
---|
291 | $form_state['values'][$field_name]=array('value'=>0); |
---|
292 | } |
---|
293 | } else { |
---|
294 | if (empty($form_state['values'][$field_name][0])) { |
---|
295 | $form_state['values'][$field_name][0]=array('value'=>0); |
---|
296 | } |
---|
297 | } |
---|
298 | |
---|
299 | drupal_execute('editablefields_form', $form_state, $node, $field_name, $delta); |
---|
300 | |
---|
301 | $err = drupal_get_messages(); |
---|
302 | |
---|
303 | if (count($err) > 0) { |
---|
304 | drupal_set_header('HTTP/1.1 404 Not Found'); |
---|
305 | // format the error message suitable for a popup window in simple text. |
---|
306 | foreach ($err as $type => $messages) { |
---|
307 | foreach ($messages as $message) { |
---|
308 | print $type . ' : ' . $message . "\n"; |
---|
309 | } |
---|
310 | } |
---|
311 | exit(); |
---|
312 | } |
---|
313 | |
---|
314 | $field = content_fields($field_name); |
---|
315 | if (content_handle('widget', 'multiple values', $field) == CONTENT_HANDLE_CORE) { |
---|
316 | if ($node->{$field_name}[$delta] != $form_state['values'][$field_name][0]) { |
---|
317 | $node->{$field_name}[$delta] = $form_state['values'][$field_name][0]; |
---|
318 | node_save($node); |
---|
319 | } |
---|
320 | } |
---|
321 | else { |
---|
322 | if ($node->{$field_name} != $form_state['values'][$field_name]) { |
---|
323 | $node->{$field_name} = $form_state['values'][$field_name]; |
---|
324 | node_save($node); |
---|
325 | } |
---|
326 | } |
---|
327 | // make sure sensible headers etc are sent... |
---|
328 | drupal_set_header('Content-Type: text; charset=utf-8'); |
---|
329 | } |
---|
330 | else { |
---|
331 | drupal_set_header('HTTP/1.1 404 Not Found'); |
---|
332 | print t('No field found, of name: %field', array('%field' => $field_name)); |
---|
333 | } |
---|
334 | } |
---|
335 | else { |
---|
336 | drupal_set_header('HTTP/1.1 404 Not Found'); |
---|
337 | print t('No write permissions for %field', array('%field' => $field_name)); |
---|
338 | } |
---|
339 | exit(); |
---|
340 | } |
---|