← Back to branch summary

~ubuntu-branches/ubuntu/breezy/koffice/breezy

« back to all changes in this revision

Viewing changes to kivio/kiviopart/kivio_command.cc

  • Committer: Bazaar Package Importer
  • Author(s): Ben Burton
  • Date: 2004-05-09 11:33:00 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040509113300-vfrdadqsvjfuhn3b
Tags: 1:1.3.1-1
http://bugs.debian.org/246623
http://bugs.debian.org/246209
http://bugs.debian.org/221256
http://bugs.debian.org/227568
* New upstream bugfix release.
* Built against newer imagemagick (closes: #246623).
* Made koffice-libs/kformula recommend/depend on latex-xft-fonts, which
  provides mathematical fonts that the formula editor can use.  Also
  patched the kformula part to make these fonts the default.
* Changed kword menu hint from "WordProcessors" to "Word processors"
  (closes: #246209).
* Spellchecker configuration is now fixed (closes: #221256, #227568).

Show diffs side-by-side

added added

removed removed

Lines of Context:
kivio/kiviopart/kivio_command.cc
 
1
/* This file is part of the KDE project
 
2
   Copyright (C) 2002 Laurent Montel <lmontel@mandrakesoft.com>
 
3
 
 
4
   This library is free software; you can redistribute it and/or
 
5
   modify it under the terms of the GNU Library General Public
 
6
   License as published by the Free Software Foundation; either
 
7
   version 2 of the License, or (at your option) any later version.
 
8
 
 
9
   This library is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
12
   Library General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Library General Public License
 
15
   along with this library; see the file COPYING.LIB.  If not, write to
 
16
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
17
   Boston, MA 02111-1307, USA.
 
18
*/
 
19
#include <kcommand.h>
 
20
#include <koGlobal.h>
 
21
#include "kivio_command.h"
 
22
#include "kivio_page.h"
 
23
#include "kivio_map.h"
 
24
#include "kivio_doc.h"
 
25
#include "kivio_layer.h"
 
26
 
 
27
KivioChangePageNameCommand::KivioChangePageNameCommand(const QString &_name,  const QString & _oldPageName, const QString & _newPageName, KivioPage *_page)
 
28
    : KNamedCommand( _name ),
 
29
      oldPageName(_oldPageName ),
 
30
      newPageName(_newPageName ),
 
31
      m_page( _page )
 
32
{
 
33
 
 
34
}
 
35
 
 
36
KivioChangePageNameCommand::~KivioChangePageNameCommand()
 
37
{
 
38
}
 
39
 
 
40
void KivioChangePageNameCommand::execute()
 
41
{
 
42
    m_page->setPageName( newPageName );
 
43
}
 
44
 
 
45
void KivioChangePageNameCommand::unexecute()
 
46
{
 
47
    m_page->setPageName( oldPageName);
 
48
}
 
49
 
 
50
 
 
51
KivioHidePageCommand::KivioHidePageCommand(const QString &_name, KivioPage *_page)
 
52
    : KNamedCommand( _name ),
 
53
      m_page( _page )
 
54
{
 
55
}
 
56
 
 
57
KivioHidePageCommand::~KivioHidePageCommand()
 
58
{
 
59
}
 
60
 
 
61
void KivioHidePageCommand::execute()
 
62
{
 
63
    m_page->setHidePage( true );
 
64
}
 
65
 
 
66
void KivioHidePageCommand::unexecute()
 
67
{
 
68
    m_page->setHidePage( false );
 
69
}
 
70
 
 
71
KivioShowPageCommand::KivioShowPageCommand( const QString &_name, KivioPage *_page)
 
72
    : KivioHidePageCommand( _name, _page)
 
73
{
 
74
}
 
75
 
 
76
 
 
77
KivioAddPageCommand::KivioAddPageCommand(const QString &_name, KivioPage *_page)
 
78
    : KNamedCommand( _name ),
 
79
      m_page( _page )
 
80
{
 
81
}
 
82
 
 
83
KivioAddPageCommand::~KivioAddPageCommand()
 
84
{
 
85
}
 
86
 
 
87
void KivioAddPageCommand::execute()
 
88
{
 
89
    m_page->map()->insertPage( m_page );
 
90
    m_page->doc()->insertPage( m_page );
 
91
}
 
92
 
 
93
void KivioAddPageCommand::unexecute()
 
94
{
 
95
    m_page->map()->takePage( m_page );
 
96
    m_page->doc()->takePage( m_page );
 
97
}
 
98
 
 
99
KivioRemovePageCommand::KivioRemovePageCommand(const QString &_name, KivioPage *_page)
 
100
    : KNamedCommand( _name ),
 
101
      m_page( _page )
 
102
{
 
103
}
 
104
 
 
105
KivioRemovePageCommand::~KivioRemovePageCommand()
 
106
{
 
107
}
 
108
 
 
109
void KivioRemovePageCommand::execute()
 
110
{
 
111
    m_page->map()->takePage( m_page );
 
112
    m_page->doc()->takePage( m_page );
 
113
}
 
114
 
 
115
void KivioRemovePageCommand::unexecute()
 
116
{
 
117
    m_page->map()->insertPage( m_page );
 
118
    m_page->doc()->insertPage( m_page );
 
119
 
 
120
}
 
121
 
 
122
KivioAddStencilCommand::KivioAddStencilCommand(const QString &_name, KivioPage *_page,  KivioLayer * _layer, KivioStencil *_stencil )
 
123
    : KNamedCommand( _name ),
 
124
      m_page( _page ),
 
125
      m_layer( _layer),
 
126
      m_stencil( _stencil)
 
127
{
 
128
}
 
129
 
 
130
KivioAddStencilCommand::~KivioAddStencilCommand()
 
131
{
 
132
}
 
133
 
 
134
void KivioAddStencilCommand::execute()
 
135
{
 
136
    m_layer->insertStencil( m_stencil );
 
137
    m_page->doc()->updateView(m_page);
 
138
    m_stencil->unselect();
 
139
    m_stencil->searchForConnections(m_page, 4.0); //FIXME: The threshold should probably be zoomed....
 
140
    m_page->doc()->slotSelectionChanged();
 
141
}
 
142
 
 
143
void KivioAddStencilCommand::unexecute()
 
144
{
 
145
    m_layer->takeStencilFromList( m_stencil );
 
146
    m_page->doc()->updateView(m_page);
 
147
    m_stencil->unselect();
 
148
    m_page->doc()->slotSelectionChanged();
 
149
}
 
150
 
 
151
KivioRemoveStencilCommand::KivioRemoveStencilCommand(const QString &_name, KivioPage *_page,  KivioLayer * _layer, KivioStencil *_stencil )
 
152
    : KivioAddStencilCommand(_name, _page, _layer, _stencil )
 
153
{
 
154
}
 
155
 
 
156
KivioChangeStencilTextCommand::KivioChangeStencilTextCommand( const QString &_name, KivioStencil *_stencil, const QString & _oldText, const QString & _newText, KivioPage *_page)
 
157
    : KNamedCommand( _name ),
 
158
      m_stencil( _stencil),
 
159
      oldText( _oldText ),
 
160
      newText( _newText ),
 
161
      m_page( _page)
 
162
{
 
163
}
 
164
 
 
165
KivioChangeStencilTextCommand::~KivioChangeStencilTextCommand()
 
166
{
 
167
}
 
168
 
 
169
void KivioChangeStencilTextCommand::execute()
 
170
{
 
171
    m_stencil->setText( newText );
 
172
    m_page->doc()->updateView(m_page);
 
173
}
 
174
 
 
175
void KivioChangeStencilTextCommand::unexecute()
 
176
{
 
177
    m_stencil->setText( oldText );
 
178
    m_page->doc()->updateView(m_page);
 
179
}
 
180
 
 
181
 
 
182
KivioAddLayerCommand::KivioAddLayerCommand( const QString &_name, KivioPage *_page, KivioLayer * _layer, int _pos )
 
183
    :KNamedCommand( _name ),
 
184
     m_page( _page ),
 
185
     m_layer( _layer),
 
186
     layerPos(_pos)
 
187
{
 
188
}
 
189
 
 
190
KivioAddLayerCommand::~KivioAddLayerCommand()
 
191
{
 
192
}
 
193
 
 
194
void KivioAddLayerCommand::execute()
 
195
{
 
196
    m_page->insertLayer( layerPos-1, m_layer );
 
197
    m_page->doc()->updateView(m_page);
 
198
    m_page->doc()->resetLayerPanel();
 
199
 
 
200
}
 
201
 
 
202
void KivioAddLayerCommand::unexecute()
 
203
{
 
204
    m_page->takeLayer( m_layer );
 
205
    m_page->doc()->updateView(m_page);
 
206
    m_page->doc()->resetLayerPanel();
 
207
}
 
208
 
 
209
 
 
210
KivioRemoveLayerCommand::KivioRemoveLayerCommand( const QString &_name, KivioPage *_page, KivioLayer * _layer, int _pos )
 
211
    :KivioAddLayerCommand( _name, _page, _layer, _pos )
 
212
{
 
213
}
 
214
 
 
215
KivioRenameLayerCommand::KivioRenameLayerCommand( const QString &_name, KivioLayer * _layer, const QString & _oldName, const QString & _newName)
 
216
    :KNamedCommand( _name ),
 
217
     m_layer( _layer ),
 
218
     oldName( _oldName),
 
219
     newName( _newName)
 
220
{
 
221
}
 
222
 
 
223
KivioRenameLayerCommand::~KivioRenameLayerCommand()
 
224
{
 
225
}
 
226
 
 
227
void KivioRenameLayerCommand::execute()
 
228
{
 
229
    m_layer->setName(newName);
 
230
    m_layer->page()->doc()->resetLayerPanel();
 
231
}
 
232
 
 
233
void KivioRenameLayerCommand::unexecute()
 
234
{
 
235
    m_layer->setName(oldName);
 
236
    m_layer->page()->doc()->resetLayerPanel();
 
237
}
 
238
 
 
239
KivioResizeStencilCommand::KivioResizeStencilCommand( const QString &_name, KivioStencil *_stencil, KivioRect _initSize, KivioRect _endSize, KivioPage *_page)
 
240
    :KNamedCommand( _name ),
 
241
     m_stencil( _stencil),
 
242
     initSize( _initSize),
 
243
     endSize( _endSize ),
 
244
     m_page( _page)
 
245
{
 
246
}
 
247
 
 
248
KivioResizeStencilCommand::~KivioResizeStencilCommand()
 
249
{
 
250
}
 
251
 
 
252
void KivioResizeStencilCommand::execute()
 
253
{
 
254
    m_stencil->setDimensions( endSize.w(), endSize.h() );
 
255
    m_stencil->setPosition( endSize.x(), endSize.y() );
 
256
    m_page->doc()->updateView(m_page);
 
257
}
 
258
 
 
259
void KivioResizeStencilCommand::unexecute()
 
260
{
 
261
    m_stencil->setDimensions( initSize.w(), initSize.h() );
 
262
    m_stencil->setPosition( initSize.x(), initSize.y() );
 
263
    m_page->doc()->updateView(m_page);
 
264
}
 
265
 
 
266
 
 
267
KivioMoveStencilCommand::KivioMoveStencilCommand( const QString &_name, KivioStencil *_stencil, KivioRect _initSize, KivioRect _endSize, KivioPage *_page)
 
268
    :KNamedCommand( _name ),
 
269
     m_stencil( _stencil),
 
270
     initSize( _initSize),
 
271
     endSize( _endSize ),
 
272
     m_page( _page)
 
273
{
 
274
}
 
275
 
 
276
KivioMoveStencilCommand::~KivioMoveStencilCommand()
 
277
{
 
278
}
 
279
 
 
280
void KivioMoveStencilCommand::execute()
 
281
{
 
282
    m_stencil->setDimensions( endSize.w(), endSize.h() );
 
283
    m_stencil->setPosition( endSize.x(), endSize.y() );
 
284
    m_page->doc()->updateView(m_page);
 
285
}
 
286
 
 
287
void KivioMoveStencilCommand::unexecute()
 
288
{
 
289
    m_stencil->setDimensions( initSize.w(), initSize.h() );
 
290
    m_stencil->setPosition( initSize.x(), initSize.y() );
 
291
    m_page->doc()->updateView(m_page);
 
292
}
 
293
 
 
294
KivioChangeLayoutCommand::KivioChangeLayoutCommand( const QString &_name, KivioPage *_page, KoPageLayout _oldLayout, KoPageLayout _newLayout)
 
295
    :KNamedCommand( _name),
 
296
     m_page(_page),
 
297
     oldLayout( _oldLayout),
 
298
     newLayout( _newLayout)
 
299
{
 
300
}
 
301
 
 
302
KivioChangeLayoutCommand::~KivioChangeLayoutCommand()
 
303
{
 
304
}
 
305
 
 
306
void KivioChangeLayoutCommand::execute()
 
307
{
 
308
    m_page->setPaperLayout(newLayout);
 
309
}
 
310
 
 
311
void KivioChangeLayoutCommand::unexecute()
 
312
{
 
313
    m_page->setPaperLayout(oldLayout);
 
314
}
 
315
 
 
316
KivioChangeStencilHAlignmentCommand::KivioChangeStencilHAlignmentCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, int _oldAlign,  int _newAlign)
 
317
    :KNamedCommand( _name),
 
318
     m_page(_page),
 
319
     m_stencil( _stencil ),
 
320
     oldAlign( _oldAlign),
 
321
     newAlign( _newAlign)
 
322
{
 
323
}
 
324
 
 
325
KivioChangeStencilHAlignmentCommand::~KivioChangeStencilHAlignmentCommand()
 
326
{
 
327
}
 
328
 
 
329
void KivioChangeStencilHAlignmentCommand::execute()
 
330
{
 
331
    m_stencil->setHTextAlign( newAlign );
 
332
    m_page->doc()->updateView(m_page);
 
333
    m_page->doc()->slotSelectionChanged();
 
334
}
 
335
 
 
336
void KivioChangeStencilHAlignmentCommand::unexecute()
 
337
{
 
338
    m_stencil->setHTextAlign( oldAlign );
 
339
    m_page->doc()->updateView(m_page);
 
340
    m_page->doc()->slotSelectionChanged();
 
341
}
 
342
 
 
343
KivioChangeStencilVAlignmentCommand::KivioChangeStencilVAlignmentCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, int _oldAlign,  int _newAlign)
 
344
    :KNamedCommand( _name),
 
345
     m_page(_page),
 
346
     m_stencil( _stencil ),
 
347
     oldAlign( _oldAlign),
 
348
     newAlign( _newAlign)
 
349
{
 
350
}
 
351
 
 
352
KivioChangeStencilVAlignmentCommand::~KivioChangeStencilVAlignmentCommand()
 
353
{
 
354
}
 
355
 
 
356
void KivioChangeStencilVAlignmentCommand::execute()
 
357
{
 
358
    m_stencil->setHTextAlign( newAlign );
 
359
    m_page->doc()->updateView(m_page);
 
360
    m_page->doc()->slotSelectionChanged();
 
361
}
 
362
 
 
363
void KivioChangeStencilVAlignmentCommand::unexecute()
 
364
{
 
365
    m_stencil->setHTextAlign( oldAlign );
 
366
    m_page->doc()->updateView(m_page);
 
367
    m_page->doc()->slotSelectionChanged();
 
368
}
 
369
 
 
370
 
 
371
KivioChangeStencilFontCommand::KivioChangeStencilFontCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, const QFont &_oldFont,  const QFont & _newFont)
 
372
    :KNamedCommand( _name),
 
373
     m_page(_page),
 
374
     m_stencil( _stencil ),
 
375
     oldFont( _oldFont),
 
376
     newFont( _newFont)
 
377
{
 
378
}
 
379
 
 
380
KivioChangeStencilFontCommand::~KivioChangeStencilFontCommand()
 
381
{
 
382
}
 
383
 
 
384
void KivioChangeStencilFontCommand::execute()
 
385
{
 
386
    m_stencil->setTextFont( newFont );
 
387
    m_page->doc()->updateView(m_page);
 
388
    m_page->doc()->slotSelectionChanged();
 
389
}
 
390
 
 
391
void KivioChangeStencilFontCommand::unexecute()
 
392
{
 
393
    m_stencil->setTextFont( oldFont );
 
394
    m_page->doc()->updateView(m_page);
 
395
    m_page->doc()->slotSelectionChanged();
 
396
}
 
397
 
 
398
KivioChangeStencilColorCommand::KivioChangeStencilColorCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, const QColor &_oldColor,  const QColor & _newColor, ColorType _type)
 
399
    :KNamedCommand( _name),
 
400
     m_page(_page),
 
401
     m_stencil( _stencil ),
 
402
     oldColor( _oldColor),
 
403
     newColor( _newColor),
 
404
     type( _type )
 
405
{
 
406
}
 
407
 
 
408
KivioChangeStencilColorCommand::~KivioChangeStencilColorCommand()
 
409
{
 
410
}
 
411
 
 
412
void KivioChangeStencilColorCommand::execute()
 
413
{
 
414
    switch( type )
 
415
    {
 
416
    case CT_TEXTCOLOR:
 
417
        m_stencil->setTextColor( newColor );
 
418
        break;
 
419
    case CT_BGCOLOR:
 
420
        m_stencil->setBGColor( newColor );
 
421
        break;
 
422
    case CT_FGCOLOR:
 
423
        m_stencil->setFGColor( newColor );
 
424
        break;
 
425
    }
 
426
    m_page->doc()->updateView(m_page);
 
427
    m_page->doc()->slotSelectionChanged();
 
428
}
 
429
 
 
430
void KivioChangeStencilColorCommand::unexecute()
 
431
{
 
432
    switch( type )
 
433
    {
 
434
    case CT_TEXTCOLOR:
 
435
        m_stencil->setTextColor( oldColor );
 
436
        break;
 
437
    case CT_BGCOLOR:
 
438
        m_stencil->setBGColor( oldColor );
 
439
        break;
 
440
    case CT_FGCOLOR:
 
441
        m_stencil->setFGColor( oldColor );
 
442
        break;
 
443
    }
 
444
    m_page->doc()->updateView(m_page);
 
445
    m_page->doc()->slotSelectionChanged();
 
446
}
 
447
 
 
448
 
 
449
KivioChangeLineWidthCommand::KivioChangeLineWidthCommand( const QString &_name,
 
450
    KivioPage *_page, KivioStencil * _stencil, double _oldValue, double _newValue)
 
451
    :KNamedCommand( _name),
 
452
    m_page(_page),
 
453
    m_stencil( _stencil ),
 
454
    oldValue( _oldValue),
 
455
    newValue( _newValue)
 
456
{
 
457
}
 
458
 
 
459
KivioChangeLineWidthCommand::~KivioChangeLineWidthCommand()
 
460
{
 
461
}
 
462
 
 
463
void KivioChangeLineWidthCommand::execute()
 
464
{
 
465
    m_stencil->setLineWidth( newValue );
 
466
    m_page->doc()->updateView(m_page);
 
467
    m_page->doc()->slotSelectionChanged();
 
468
}
 
469
 
 
470
void KivioChangeLineWidthCommand::unexecute()
 
471
{
 
472
    m_stencil->setLineWidth( oldValue );
 
473
    m_page->doc()->updateView(m_page);
 
474
    m_page->doc()->slotSelectionChanged();
 
475
}
 
476
 
 
477
 
 
478
KivioChangeBeginEndArrowCommand::KivioChangeBeginEndArrowCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, int _oldArrow,  int _newArrow, bool _beginArrow)
 
479
    :KNamedCommand( _name),
 
480
     m_page(_page),
 
481
     m_stencil( _stencil ),
 
482
     oldArrow( _oldArrow),
 
483
     newArrow( _newArrow),
 
484
     beginArrow(_beginArrow)
 
485
{
 
486
}
 
487
 
 
488
KivioChangeBeginEndArrowCommand::~KivioChangeBeginEndArrowCommand()
 
489
{
 
490
}
 
491
 
 
492
void KivioChangeBeginEndArrowCommand::execute()
 
493
{
 
494
    if (beginArrow)
 
495
        m_stencil->setStartAHType(newArrow);
 
496
    else
 
497
        m_stencil->setEndAHType(newArrow);
 
498
    m_page->doc()->updateView(m_page);
 
499
    m_page->doc()->slotSelectionChanged();
 
500
}
 
501
 
 
502
void KivioChangeBeginEndArrowCommand::unexecute()
 
503
{
 
504
    if (beginArrow)
 
505
        m_stencil->setStartAHType(oldArrow);
 
506
    else
 
507
        m_stencil->setEndAHType(oldArrow);
 
508
    m_page->doc()->updateView(m_page);
 
509
    m_page->doc()->slotSelectionChanged();
 
510
}
 
511
 
 
512
 
 
513
KivioChangeBeginEndSizeArrowCommand::KivioChangeBeginEndSizeArrowCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, float _oldH,float _oldW, float _newH,float _newW, bool _beginArrow)
 
514
    :KNamedCommand( _name),
 
515
     m_page(_page),
 
516
     m_stencil( _stencil ),
 
517
     oldWidth( _oldW),
 
518
     oldLength( _oldH),
 
519
     newWidth( _newW),
 
520
     newLength( _newH),
 
521
     beginArrow(_beginArrow)
 
522
{
 
523
}
 
524
 
 
525
KivioChangeBeginEndSizeArrowCommand::~KivioChangeBeginEndSizeArrowCommand()
 
526
{
 
527
}
 
528
 
 
529
void KivioChangeBeginEndSizeArrowCommand::execute()
 
530
{
 
531
    if (beginArrow)
 
532
    {
 
533
        m_stencil->setStartAHWidth(newWidth);
 
534
        m_stencil->setStartAHLength(newLength);
 
535
    }
 
536
    else
 
537
    {
 
538
        m_stencil->setEndAHWidth(newWidth);
 
539
        m_stencil->setEndAHLength(newLength);
 
540
    }
 
541
    m_page->doc()->updateView(m_page);
 
542
    m_page->doc()->slotSelectionChanged();
 
543
}
 
544
 
 
545
void KivioChangeBeginEndSizeArrowCommand::unexecute()
 
546
{
 
547
    if (beginArrow)
 
548
    {
 
549
        m_stencil->setStartAHWidth(oldWidth);
 
550
        m_stencil->setStartAHLength(oldLength);
 
551
    }
 
552
    else
 
553
    {
 
554
        m_stencil->setEndAHWidth(oldWidth);
 
555
        m_stencil->setEndAHLength(oldLength);
 
556
    }
 
557
    m_page->doc()->updateView(m_page);
 
558
    m_page->doc()->slotSelectionChanged();
 
559
}
 
560
 
 
561
KivioChangeStencilProtectCommand::KivioChangeStencilProtectCommand( const QString &_name, KivioPage *_page, KivioStencil * _stencil, bool _state, KVP_TYPE _type)
 
562
    :KNamedCommand( _name),
 
563
     m_page(_page),
 
564
     m_stencil( _stencil ),
 
565
     type( _type),
 
566
     m_bValue( _state)
 
567
{
 
568
}
 
569
 
 
570
void KivioChangeStencilProtectCommand::execute()
 
571
{
 
572
    changeValue( m_bValue );
 
573
}
 
574
 
 
575
void KivioChangeStencilProtectCommand::unexecute()
 
576
{
 
577
    changeValue( !m_bValue );
 
578
}
 
579
 
 
580
void KivioChangeStencilProtectCommand::changeValue( bool b )
 
581
{
 
582
    switch( type )
 
583
    {
 
584
    case KV_POSX:
 
585
         m_stencil->protection()->setBit( kpX, b );
 
586
        break;
 
587
    case KV_POSY:
 
588
         m_stencil->protection()->setBit( kpY, b );
 
589
        break;
 
590
    case KV_WIDTH:
 
591
         m_stencil->protection()->setBit( kpWidth, b );
 
592
        break;
 
593
    case KV_HEIGHT:
 
594
        m_stencil->protection()->setBit( kpHeight, b );
 
595
        break;
 
596
    case KV_ASPECT:
 
597
        m_stencil->protection()->setBit( kpAspect, b );
 
598
        break;
 
599
    case KV_DELETE:
 
600
         m_stencil->protection()->setBit( kpDeletion, b);
 
601
        break;
 
602
    default:
 
603
        break;
 
604
    }
 
605
    m_page->doc()->updateProtectPanelCheckBox();
 
606
}
 
607