1 #define __SP_KNOT_C__
3 /** \file
4 * SPKnot implementation
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 1999-2005 authors
11 * Copyright (C) 2001-2002 Ximian, Inc.
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #ifdef HAVE_CONFIG_H
17 # include <config.h>
18 #endif
19 #include <gdk/gdkkeysyms.h>
20 #include <glibmm/i18n.h>
21 #include "helper/sp-marshal.h"
22 #include "display/sodipodi-ctrl.h"
23 #include "desktop.h"
24 #include "desktop-handles.h"
25 #include "knot.h"
26 #include "document.h"
27 #include "preferences.h"
28 #include "message-stack.h"
29 #include "message-context.h"
30 #include "event-context.h"
32 #define KNOT_EVENT_MASK (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | \
33 GDK_POINTER_MOTION_MASK | \
34 GDK_POINTER_MOTION_HINT_MASK | \
35 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)
37 static bool nograb = false;
39 static bool grabbed = FALSE;
40 static bool moved = FALSE;
42 static gint xp = 0, yp = 0; // where drag started
43 static gint tolerance = 0;
44 static bool within_tolerance = false;
46 static bool transform_escaped = false; // true iff resize or rotate was cancelled by esc.
48 enum {
49 EVENT,
50 CLICKED,
51 DOUBLECLICKED,
52 GRABBED,
53 UNGRABBED,
54 MOVED,
55 REQUEST,
56 DISTANCE,
57 LAST_SIGNAL
58 };
60 static void sp_knot_class_init(SPKnotClass *klass);
61 static void sp_knot_init(SPKnot *knot);
62 static void sp_knot_dispose(GObject *object);
64 static int sp_knot_handler(SPCanvasItem *item, GdkEvent *event, SPKnot *knot);
65 static void sp_knot_set_ctrl_state(SPKnot *knot);
67 static GObjectClass *parent_class;
68 static guint knot_signals[LAST_SIGNAL] = { 0 };
70 /**
71 * Registers SPKnot class and returns its type number.
72 */
73 GType sp_knot_get_type()
74 {
75 static GType type = 0;
76 if (!type) {
77 GTypeInfo info = {
78 sizeof(SPKnotClass),
79 NULL, /* base_init */
80 NULL, /* base_finalize */
81 (GClassInitFunc) sp_knot_class_init,
82 NULL, /* class_finalize */
83 NULL, /* class_data */
84 sizeof (SPKnot),
85 16, /* n_preallocs */
86 (GInstanceInitFunc) sp_knot_init,
87 NULL
88 };
89 type = g_type_register_static (G_TYPE_OBJECT, "SPKnot", &info, (GTypeFlags) 0);
90 }
91 return type;
92 }
94 /**
95 * SPKnot vtable initialization.
96 */
97 static void sp_knot_class_init(SPKnotClass *klass)
98 {
99 GObjectClass *object_class = (GObjectClass*)klass;
101 parent_class = (GObjectClass*) g_type_class_peek_parent(klass);
103 object_class->dispose = sp_knot_dispose;
105 knot_signals[EVENT] = g_signal_new("event",
106 G_TYPE_FROM_CLASS(klass),
107 G_SIGNAL_RUN_LAST,
108 G_STRUCT_OFFSET(SPKnotClass, event),
109 NULL, NULL,
110 sp_marshal_BOOLEAN__POINTER,
111 G_TYPE_BOOLEAN, 1,
112 GDK_TYPE_EVENT);
114 knot_signals[CLICKED] = g_signal_new("clicked",
115 G_TYPE_FROM_CLASS(klass),
116 G_SIGNAL_RUN_FIRST,
117 G_STRUCT_OFFSET(SPKnotClass, clicked),
118 NULL, NULL,
119 sp_marshal_NONE__UINT,
120 G_TYPE_NONE, 1,
121 G_TYPE_UINT);
123 knot_signals[DOUBLECLICKED] = g_signal_new("doubleclicked",
124 G_TYPE_FROM_CLASS(klass),
125 G_SIGNAL_RUN_FIRST,
126 G_STRUCT_OFFSET(SPKnotClass, doubleclicked),
127 NULL, NULL,
128 sp_marshal_NONE__UINT,
129 G_TYPE_NONE, 1,
130 G_TYPE_UINT);
132 knot_signals[GRABBED] = g_signal_new("grabbed",
133 G_TYPE_FROM_CLASS(klass),
134 G_SIGNAL_RUN_FIRST,
135 G_STRUCT_OFFSET(SPKnotClass, grabbed),
136 NULL, NULL,
137 sp_marshal_NONE__UINT,
138 G_TYPE_NONE, 1,
139 G_TYPE_UINT);
141 knot_signals[UNGRABBED] = g_signal_new("ungrabbed",
142 G_TYPE_FROM_CLASS(klass),
143 G_SIGNAL_RUN_FIRST,
144 G_STRUCT_OFFSET(SPKnotClass, ungrabbed),
145 NULL, NULL,
146 sp_marshal_NONE__UINT,
147 G_TYPE_NONE, 1,
148 G_TYPE_UINT);
150 knot_signals[MOVED] = g_signal_new("moved",
151 G_TYPE_FROM_CLASS(klass),
152 G_SIGNAL_RUN_FIRST,
153 G_STRUCT_OFFSET(SPKnotClass, moved),
154 NULL, NULL,
155 sp_marshal_NONE__POINTER_UINT,
156 G_TYPE_NONE, 2,
157 G_TYPE_POINTER, G_TYPE_UINT);
159 knot_signals[REQUEST] = g_signal_new("request",
160 G_TYPE_FROM_CLASS(klass),
161 G_SIGNAL_RUN_LAST,
162 G_STRUCT_OFFSET(SPKnotClass, request),
163 NULL, NULL,
164 sp_marshal_BOOLEAN__POINTER_UINT,
165 G_TYPE_BOOLEAN, 2,
166 G_TYPE_POINTER, G_TYPE_UINT);
168 knot_signals[DISTANCE] = g_signal_new("distance",
169 G_TYPE_FROM_CLASS(klass),
170 G_SIGNAL_RUN_LAST,
171 G_STRUCT_OFFSET(SPKnotClass, distance),
172 NULL, NULL,
173 sp_marshal_DOUBLE__POINTER_UINT,
174 G_TYPE_DOUBLE, 2,
175 G_TYPE_POINTER, G_TYPE_UINT);
177 const gchar *nograbenv = getenv("INKSCAPE_NO_GRAB");
178 nograb = (nograbenv && *nograbenv && (*nograbenv != '0'));
179 }
181 /**
182 * Callback for SPKnot initialization.
183 */
184 static void sp_knot_init(SPKnot *knot)
185 {
186 knot->desktop = NULL;
187 knot->item = NULL;
188 knot->flags = 0;
190 knot->size = 8;
191 knot->pos = Geom::Point(0, 0);
192 knot->grabbed_rel_pos = Geom::Point(0, 0);
193 knot->anchor = GTK_ANCHOR_CENTER;
194 knot->shape = SP_KNOT_SHAPE_SQUARE;
195 knot->mode = SP_KNOT_MODE_XOR;
196 knot->tip = NULL;
197 knot->_event_handler_id = 0;
198 knot->pressure = 0;
200 knot->fill[SP_KNOT_STATE_NORMAL] = 0xffffff00;
201 knot->fill[SP_KNOT_STATE_MOUSEOVER] = 0xff0000ff;
202 knot->fill[SP_KNOT_STATE_DRAGGING] = 0x0000ffff;
204 knot->stroke[SP_KNOT_STATE_NORMAL] = 0x01000000;
205 knot->stroke[SP_KNOT_STATE_MOUSEOVER] = 0x01000000;
206 knot->stroke[SP_KNOT_STATE_DRAGGING] = 0x01000000;
208 knot->image[SP_KNOT_STATE_NORMAL] = NULL;
209 knot->image[SP_KNOT_STATE_MOUSEOVER] = NULL;
210 knot->image[SP_KNOT_STATE_DRAGGING] = NULL;
212 knot->cursor[SP_KNOT_STATE_NORMAL] = NULL;
213 knot->cursor[SP_KNOT_STATE_MOUSEOVER] = NULL;
214 knot->cursor[SP_KNOT_STATE_DRAGGING] = NULL;
216 knot->saved_cursor = NULL;
217 knot->pixbuf = NULL;
218 }
220 /**
221 * Called before SPKnot destruction.
222 */
223 static void sp_knot_dispose(GObject *object)
224 {
225 SPKnot *knot = (SPKnot *) object;
227 if ((knot->flags & SP_KNOT_GRABBED) && gdk_pointer_is_grabbed ()) {
228 // This happens e.g. when deleting a node in node tool while dragging it
229 gdk_pointer_ungrab (GDK_CURRENT_TIME);
230 }
232 if (knot->_event_handler_id > 0)
233 {
234 g_signal_handler_disconnect(G_OBJECT (knot->item), knot->_event_handler_id);
235 knot->_event_handler_id = 0;
236 }
238 if (knot->item) {
239 gtk_object_destroy (GTK_OBJECT (knot->item));
240 knot->item = NULL;
241 }
243 for (gint i = 0; i < SP_KNOT_VISIBLE_STATES; i++) {
244 if (knot->cursor[i]) {
245 gdk_cursor_unref(knot->cursor[i]);
246 knot->cursor[i] = NULL;
247 }
248 }
250 if (knot->tip) {
251 g_free(knot->tip);
252 knot->tip = NULL;
253 }
255 if (parent_class->dispose) {
256 (*parent_class->dispose) (object);
257 }
258 }
260 /**
261 * Update knot for dragging and tell canvas an item was grabbed.
262 */
263 void sp_knot_start_dragging(SPKnot *knot, Geom::Point const &p, gint x, gint y, guint32 etime)
264 {
265 // save drag origin
266 xp = x;
267 yp = y;
268 within_tolerance = true;
270 knot->grabbed_rel_pos = p - knot->pos;
271 knot->drag_origin = knot->pos;
272 if (!nograb) {
273 sp_canvas_item_grab(knot->item,
274 KNOT_EVENT_MASK,
275 knot->cursor[SP_KNOT_STATE_DRAGGING],
276 etime);
277 }
278 sp_knot_set_flag(knot, SP_KNOT_GRABBED, TRUE);
279 grabbed = TRUE;
280 }
282 /**
283 * Called to handle events on knots.
284 */
285 static int sp_knot_handler(SPCanvasItem */*item*/, GdkEvent *event, SPKnot *knot)
286 {
287 g_assert(knot != NULL);
288 g_assert(SP_IS_KNOT(knot));
290 /* Run client universal event handler, if present */
292 gboolean consumed = FALSE;
294 g_signal_emit(knot, knot_signals[EVENT], 0, event, &consumed);
296 if (consumed) {
297 return TRUE;
298 }
300 g_object_ref(knot);
301 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
302 tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
304 switch (event->type) {
305 case GDK_2BUTTON_PRESS:
306 if (event->button.button == 1) {
307 g_signal_emit(knot, knot_signals[DOUBLECLICKED], 0, event->button.state);
309 grabbed = FALSE;
310 moved = FALSE;
311 consumed = TRUE;
312 }
313 break;
314 case GDK_BUTTON_PRESS:
315 if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
316 Geom::Point const p = knot->desktop->w2d(Geom::Point(event->button.x, event->button.y));
317 sp_knot_start_dragging(knot, p, (gint) event->button.x, (gint) event->button.y, event->button.time);
318 consumed = TRUE;
319 }
320 break;
321 case GDK_BUTTON_RELEASE:
322 if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
323 // If we have any pending snap event, then invoke it now
324 if (knot->desktop->event_context->_delayed_snap_event) {
325 sp_event_context_snap_watchdog_callback(knot->desktop->event_context->_delayed_snap_event);
326 }
328 sp_event_context_discard_delayed_snap_event(knot->desktop->event_context);
330 knot->pressure = 0;
331 if (transform_escaped) {
332 transform_escaped = false;
333 consumed = TRUE;
334 } else {
335 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
336 if (!nograb) {
337 sp_canvas_item_ungrab(knot->item, event->button.time);
338 }
339 if (moved) {
340 sp_knot_set_flag(knot,
341 SP_KNOT_DRAGGING,
342 FALSE);
343 g_signal_emit(knot,
344 knot_signals[UNGRABBED], 0,
345 event->button.state);
346 knot->_ungrabbed_signal.emit(knot);
347 } else {
348 g_signal_emit(knot,
349 knot_signals[CLICKED], 0,
350 event->button.state);
351 knot->_click_signal.emit(knot, event->button.state);
352 }
353 grabbed = FALSE;
354 moved = FALSE;
355 consumed = TRUE;
356 }
357 }
358 break;
359 case GDK_MOTION_NOTIFY:
360 if (grabbed && !knot->desktop->event_context->space_panning) {
361 consumed = TRUE;
363 if ( within_tolerance
364 && ( abs( (gint) event->motion.x - xp ) < tolerance )
365 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
366 break; // do not drag if we're within tolerance from origin
367 }
369 // Once the user has moved farther than tolerance from the original location
370 // (indicating they intend to move the object, not click), then always process the
371 // motion notify coordinates as given (no snapping back to origin)
372 within_tolerance = false;
374 if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &knot->pressure))
375 knot->pressure = CLAMP (knot->pressure, 0, 1);
376 else
377 knot->pressure = 0.5;
379 if (!moved) {
380 g_signal_emit(knot,
381 knot_signals[GRABBED], 0,
382 event->motion.state);
383 sp_knot_set_flag(knot,
384 SP_KNOT_DRAGGING,
385 TRUE);
386 }
387 sp_event_context_snap_delay_handler(knot->desktop->event_context, NULL, (gpointer) knot, (GdkEventMotion *)event, DelayedSnapEvent::KNOT_HANDLER);
388 sp_knot_handler_request_position(event, knot);
389 moved = TRUE;
390 }
391 break;
392 case GDK_ENTER_NOTIFY:
393 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, TRUE);
394 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
396 if (knot->tip) {
397 knot->desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, knot->tip);
398 }
400 grabbed = FALSE;
401 moved = FALSE;
402 consumed = TRUE;
403 break;
404 case GDK_LEAVE_NOTIFY:
405 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, FALSE);
406 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
408 if (knot->tip) {
409 knot->desktop->event_context->defaultMessageContext()->clear();
410 }
412 grabbed = FALSE;
413 moved = FALSE;
414 consumed = TRUE;
415 break;
416 case GDK_KEY_PRESS: // keybindings for knot
417 switch (get_group0_keyval(&event->key)) {
418 case GDK_Escape:
419 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
420 if (!nograb) {
421 sp_canvas_item_ungrab(knot->item, event->button.time);
422 }
423 if (moved) {
424 sp_knot_set_flag(knot,
425 SP_KNOT_DRAGGING,
426 FALSE);
427 g_signal_emit(knot,
428 knot_signals[UNGRABBED], 0,
429 event->button.state);
430 sp_document_undo(sp_desktop_document(knot->desktop));
431 knot->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Node or handle drag canceled."));
432 transform_escaped = true;
433 consumed = TRUE;
434 }
435 grabbed = FALSE;
436 moved = FALSE;
437 sp_event_context_discard_delayed_snap_event(knot->desktop->event_context);
438 break;
439 default:
440 consumed = FALSE;
441 break;
442 }
443 break;
444 default:
445 break;
446 }
448 g_object_unref(knot);
450 return consumed;
451 }
453 void sp_knot_handler_request_position(GdkEvent *event, SPKnot *knot)
454 {
455 Geom::Point const motion_w(event->motion.x, event->motion.y);
456 Geom::Point const motion_dt = knot->desktop->w2d(motion_w);
457 Geom::Point p = motion_dt - knot->grabbed_rel_pos;
458 sp_knot_request_position (knot, p, event->motion.state);
459 knot->desktop->scroll_to_point (motion_dt);
460 knot->desktop->set_coordinate_status(knot->pos); // display the coordinate of knot, not cursor - they may be different!
461 if (event->motion.state & GDK_BUTTON1_MASK)
462 gobble_motion_events(GDK_BUTTON1_MASK);
463 }
465 /**
466 * Return new knot object.
467 */
468 SPKnot *sp_knot_new(SPDesktop *desktop, const gchar *tip)
469 {
470 g_return_val_if_fail(desktop != NULL, NULL);
472 SPKnot * knot = (SPKnot*) g_object_new(SP_TYPE_KNOT, 0);
474 knot->desktop = desktop;
475 knot->flags = SP_KNOT_VISIBLE;
476 if (tip) {
477 knot->tip = g_strdup (tip);
478 }
480 knot->item = sp_canvas_item_new(sp_desktop_controls (desktop),
481 SP_TYPE_CTRL,
482 "anchor", GTK_ANCHOR_CENTER,
483 "size", 8.0,
484 "filled", TRUE,
485 "fill_color", 0xffffff00,
486 "stroked", TRUE,
487 "stroke_color", 0x01000000,
488 "mode", SP_KNOT_MODE_XOR,
489 NULL);
491 knot->_event_handler_id = gtk_signal_connect(GTK_OBJECT(knot->item), "event",
492 GTK_SIGNAL_FUNC(sp_knot_handler), knot);
494 return knot;
495 }
497 /**
498 * Show knot on its canvas.
499 */
500 void sp_knot_show(SPKnot *knot)
501 {
502 g_return_if_fail(knot != NULL);
503 g_return_if_fail(SP_IS_KNOT (knot));
505 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, TRUE);
506 }
508 /**
509 * Hide knot on its canvas.
510 */
511 void sp_knot_hide(SPKnot *knot)
512 {
513 g_return_if_fail(knot != NULL);
514 g_return_if_fail(SP_IS_KNOT(knot));
516 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, FALSE);
517 }
519 /**
520 * Request or set new position for knot.
521 */
522 void sp_knot_request_position(SPKnot *knot, Geom::Point const &p, guint state)
523 {
524 g_return_if_fail(knot != NULL);
525 g_return_if_fail(SP_IS_KNOT(knot));
527 gboolean done = FALSE;
529 g_signal_emit(knot,
530 knot_signals[REQUEST], 0,
531 &p,
532 state,
533 &done);
535 /* If user did not complete, we simply move knot to new position */
537 if (!done) {
538 sp_knot_set_position (knot, p, state);
539 }
540 }
542 /**
543 * Return distance of point to knot's position; unused.
544 */
545 gdouble sp_knot_distance(SPKnot * knot, Geom::Point const &p, guint state)
546 {
547 g_return_val_if_fail(knot != NULL, 1e18);
548 g_return_val_if_fail(SP_IS_KNOT(knot), 1e18);
550 gdouble distance = Geom::L2(p - knot->pos);
552 g_signal_emit(knot,
553 knot_signals[DISTANCE], 0,
554 &p,
555 state,
556 &distance);
558 return distance;
559 }
561 /**
562 * Move knot to new position.
563 */
564 void sp_knot_set_position(SPKnot *knot, Geom::Point const &p, guint state)
565 {
566 g_return_if_fail(knot != NULL);
567 g_return_if_fail(SP_IS_KNOT (knot));
569 knot->pos = p;
571 if (knot->item) {
572 SP_CTRL(knot->item)->moveto (p);
573 }
575 g_signal_emit(knot,
576 knot_signals[MOVED], 0,
577 &p,
578 state);
579 knot->_moved_signal.emit(knot, p, state);
580 }
582 /**
583 * Move knot to new position, without emitting a MOVED signal.
584 */
585 void sp_knot_moveto(SPKnot *knot, Geom::Point const &p)
586 {
587 g_return_if_fail(knot != NULL);
588 g_return_if_fail(SP_IS_KNOT(knot));
590 knot->pos = p;
592 if (knot->item) {
593 SP_CTRL(knot->item)->moveto (p);
594 }
595 }
597 /**
598 * Returns position of knot.
599 */
600 Geom::Point sp_knot_position(SPKnot const *knot)
601 {
602 g_assert(knot != NULL);
603 g_assert(SP_IS_KNOT (knot));
605 return knot->pos;
606 }
608 /**
609 * Set flag in knot, with side effects.
610 */
611 void sp_knot_set_flag(SPKnot *knot, guint flag, bool set)
612 {
613 g_assert(knot != NULL);
614 g_assert(SP_IS_KNOT(knot));
616 if (set) {
617 knot->flags |= flag;
618 } else {
619 knot->flags &= ~flag;
620 }
622 switch (flag) {
623 case SP_KNOT_VISIBLE:
624 if (set) {
625 sp_canvas_item_show(knot->item);
626 } else {
627 sp_canvas_item_hide(knot->item);
628 }
629 break;
630 case SP_KNOT_MOUSEOVER:
631 case SP_KNOT_DRAGGING:
632 sp_knot_set_ctrl_state(knot);
633 break;
634 case SP_KNOT_GRABBED:
635 break;
636 default:
637 g_assert_not_reached();
638 break;
639 }
640 }
642 /**
643 * Update knot's pixbuf and set its control state.
644 */
645 void sp_knot_update_ctrl(SPKnot *knot)
646 {
647 if (!knot->item) {
648 return;
649 }
651 gtk_object_set(GTK_OBJECT(knot->item), "shape", knot->shape, NULL);
652 gtk_object_set(GTK_OBJECT(knot->item), "mode", knot->mode, NULL);
653 gtk_object_set(GTK_OBJECT(knot->item), "size", (gdouble) knot->size, NULL);
654 gtk_object_set(GTK_OBJECT(knot->item), "anchor", knot->anchor, NULL);
655 if (knot->pixbuf) {
656 gtk_object_set(GTK_OBJECT (knot->item), "pixbuf", knot->pixbuf, NULL);
657 }
659 sp_knot_set_ctrl_state(knot);
660 }
662 /**
663 * Set knot control state (dragging/mouseover/normal).
664 */
665 static void sp_knot_set_ctrl_state(SPKnot *knot)
666 {
667 if (knot->flags & SP_KNOT_DRAGGING) {
668 gtk_object_set(GTK_OBJECT (knot->item),
669 "fill_color",
670 knot->fill[SP_KNOT_STATE_DRAGGING],
671 NULL);
672 gtk_object_set(GTK_OBJECT (knot->item),
673 "stroke_color",
674 knot->stroke[SP_KNOT_STATE_DRAGGING],
675 NULL);
676 } else if (knot->flags & SP_KNOT_MOUSEOVER) {
677 gtk_object_set(GTK_OBJECT(knot->item),
678 "fill_color",
679 knot->fill[SP_KNOT_STATE_MOUSEOVER],
680 NULL);
681 gtk_object_set(GTK_OBJECT(knot->item),
682 "stroke_color",
683 knot->stroke[SP_KNOT_STATE_MOUSEOVER],
684 NULL);
685 } else {
686 gtk_object_set(GTK_OBJECT(knot->item),
687 "fill_color",
688 knot->fill[SP_KNOT_STATE_NORMAL],
689 NULL);
690 gtk_object_set(GTK_OBJECT(knot->item),
691 "stroke_color",
692 knot->stroke[SP_KNOT_STATE_NORMAL],
693 NULL);
694 }
695 }
699 /*
700 Local Variables:
701 mode:c++
702 c-file-style:"stroustrup"
703 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
704 indent-tabs-mode:nil
705 fill-column:99
706 End:
707 */
708 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :