← Back to branch summary

~ubuntu-branches/ubuntu/precise/moin/precise-updates

« back to all changes in this revision

Viewing changes to wiki/htdocs/applets/FCKeditor/editor/plugins/dragresizetable/fckplugin.js

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt
  • Date: 2008-11-13 16:45:52 UTC
  • mfrom: (0.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20081113164552-49t6zf2t2o5bqigh
Tags: 1.8.0-1ubuntu1
* Merge from debian unstable, remaining changes:
  - Drop recommendation of python-xml, the packages isn't anymore in
    sys.path.

Show diffs side-by-side

added added

removed removed

Lines of Context:
wiki/htdocs/applets/FCKeditor/editor/plugins/dragresizetable/fckplugin.js
 
1
var FCKDragTableHandler =
 
2
{
 
3
        "_DragState" : 0,
 
4
        "_LeftCell" : null,
 
5
        "_RightCell" : null,
 
6
        "_MouseMoveMode" : 0,   // 0 - find candidate cells for resizing, 1 - drag to resize
 
7
        "_ResizeBar" : null,
 
8
        "_OriginalX" : null,
 
9
        "_MinimumX" : null,
 
10
        "_MaximumX" : null,
 
11
        "_LastX" : null,
 
12
        "_TableMap" : null,
 
13
        "_doc" : document,
 
14
        "_IsInsideNode" : function( w, domNode, pos )
 
15
        {
 
16
                var myCoords = FCKTools.GetWindowPosition( w, domNode ) ;
 
17
                var xMin = myCoords.x ;
 
18
                var yMin = myCoords.y ;
 
19
                var xMax = parseInt( xMin, 10 ) + parseInt( domNode.offsetWidth, 10 ) ;
 
20
                var yMax = parseInt( yMin, 10 ) + parseInt( domNode.offsetHeight, 10 ) ;
 
21
                if ( pos.x >= xMin && pos.x <= xMax && pos.y >= yMin && pos.y <= yMax )
 
22
                        return true;
 
23
                return false;
 
24
        },
 
25
        "_GetBorderCells" : function( w, tableNode, tableMap, mouse )
 
26
        {
 
27
                // Enumerate all the cells in the table.
 
28
                var cells = [] ;
 
29
                for ( var i = 0 ; i < tableNode.rows.length ; i++ )
 
30
                {
 
31
                        var r = tableNode.rows[i] ;
 
32
                        for ( var j = 0 ; j < r.cells.length ; j++ )
 
33
                                cells.push( r.cells[j] ) ;
 
34
                }
 
35
 
 
36
                if ( cells.length < 1 )
 
37
                        return null ;
 
38
 
 
39
                // Get the cells whose right or left border is nearest to the mouse cursor's x coordinate.
 
40
                var minRxDist = null ;
 
41
                var lxDist = null ;
 
42
                var minYDist = null ;
 
43
                var rbCell = null ;
 
44
                var lbCell = null ;
 
45
                for ( var i = 0 ; i < cells.length ; i++ )
 
46
                {
 
47
                        var pos = FCKTools.GetWindowPosition( w, cells[i] ) ;
 
48
                        var rightX = pos.x + parseInt( cells[i].clientWidth, 10 ) ;
 
49
                        var rxDist = mouse.x - rightX ;
 
50
                        var yDist = mouse.y - ( pos.y + ( cells[i].clientHeight / 2 ) ) ;
 
51
                        if ( minRxDist == null ||
 
52
                                        ( Math.abs( rxDist ) <= Math.abs( minRxDist ) &&
 
53
                                          ( minYDist == null || Math.abs( yDist ) <= Math.abs( minYDist ) ) ) )
 
54
                        {
 
55
                                minRxDist = rxDist ;
 
56
                                minYDist = yDist ;
 
57
                                rbCell = cells[i] ;
 
58
                        }
 
59
                }
 
60
                /*
 
61
                var rowNode = FCKTools.GetElementAscensor( rbCell, "tr" ) ;
 
62
                var cellIndex = rbCell.cellIndex + 1 ;
 
63
                if ( cellIndex >= rowNode.cells.length )
 
64
                        return null ;
 
65
                lbCell = rowNode.cells.item( cellIndex ) ;
 
66
                */
 
67
                var rowIdx = rbCell.parentNode.rowIndex ;
 
68
                var colIdx = FCKTableHandler._GetCellIndexSpan( tableMap, rowIdx, rbCell ) ;
 
69
                var colSpan = isNaN( rbCell.colSpan ) ? 1 : rbCell.colSpan ;
 
70
                lbCell = tableMap[rowIdx][colIdx + colSpan] ;
 
71
 
 
72
                if ( ! lbCell )
 
73
                        return null ;
 
74
 
 
75
                // Abort if too far from the border.
 
76
                lxDist = mouse.x - FCKTools.GetWindowPosition( w, lbCell ).x ;
 
77
                if ( lxDist < 0 && minRxDist < 0 && minRxDist < -2 )
 
78
                        return null ;
 
79
                if ( lxDist > 0 && minRxDist > 0 && lxDist > 3 )
 
80
                        return null ;
 
81
 
 
82
                return { "leftCell" : rbCell, "rightCell" : lbCell } ;
 
83
        },
 
84
        "_GetResizeBarPosition" : function()
 
85
        {
 
86
                var row = FCKTools.GetElementAscensor( this._RightCell, "tr" ) ;
 
87
                return FCKTableHandler._GetCellIndexSpan( this._TableMap, row.rowIndex, this._RightCell ) ;
 
88
        },
 
89
        "_ResizeBarMouseDownListener" : function( evt )
 
90
        {
 
91
                if ( FCKDragTableHandler._LeftCell )
 
92
                        FCKDragTableHandler._MouseMoveMode = 1 ;
 
93
                if ( FCKBrowserInfo.IsIE )
 
94
                        FCKDragTableHandler._ResizeBar.filters.item("DXImageTransform.Microsoft.Alpha").opacity = 50 ;
 
95
                else
 
96
                        FCKDragTableHandler._ResizeBar.style.opacity = 0.5 ;
 
97
                FCKDragTableHandler._OriginalX = evt.clientX ;
 
98
 
 
99
                // Calculate maximum and minimum x-coordinate delta.
 
100
                var borderIndex = FCKDragTableHandler._GetResizeBarPosition() ;
 
101
                var offset = FCKDragTableHandler._GetIframeOffset();
 
102
                var table = FCKTools.GetElementAscensor( FCKDragTableHandler._LeftCell, "table" );
 
103
                var minX = null ;
 
104
                var maxX = null ;
 
105
                for ( var r = 0 ; r < FCKDragTableHandler._TableMap.length ; r++ )
 
106
                {
 
107
                        var leftCell = FCKDragTableHandler._TableMap[r][borderIndex - 1] ;
 
108
                        var rightCell = FCKDragTableHandler._TableMap[r][borderIndex] ;
 
109
                        var leftPosition = FCKTools.GetWindowPosition( FCK.EditorWindow, leftCell ) ;
 
110
                        var rightPosition = FCKTools.GetWindowPosition( FCK.EditorWindow, rightCell ) ;
 
111
                        var leftPadding = FCKDragTableHandler._GetCellPadding( table, leftCell ) ;
 
112
                        var rightPadding = FCKDragTableHandler._GetCellPadding( table, rightCell ) ;
 
113
                        if ( minX == null || leftPosition.x + leftPadding > minX )
 
114
                                minX = leftPosition.x + leftPadding ;
 
115
                        if ( maxX == null || rightPosition.x + rightCell.clientWidth - rightPadding < maxX )
 
116
                                maxX = rightPosition.x + rightCell.clientWidth - rightPadding ;
 
117
                }
 
118
 
 
119
                FCKDragTableHandler._MinimumX = minX + offset.x ;
 
120
                FCKDragTableHandler._MaximumX = maxX + offset.x ;
 
121
                FCKDragTableHandler._LastX = null ;
 
122
 
 
123
                if (evt.preventDefault)
 
124
                        evt.preventDefault();
 
125
                else
 
126
                        evt.returnValue = false;
 
127
        },
 
128
        "_ResizeBarMouseUpListener" : function( evt )
 
129
        {
 
130
                FCKDragTableHandler._MouseMoveMode = 0 ;
 
131
                FCKDragTableHandler._HideResizeBar() ;
 
132
 
 
133
                if ( FCKDragTableHandler._LastX == null )
 
134
                        return ;
 
135
 
 
136
                // Calculate the delta value.
 
137
                var deltaX = FCKDragTableHandler._LastX - FCKDragTableHandler._OriginalX ;
 
138
 
 
139
                // Then, build an array of current column width values.
 
140
                // This algorithm can be very slow if the cells have insane colSpan values. (e.g. colSpan=1000).
 
141
                var table = FCKTools.GetElementAscensor( FCKDragTableHandler._LeftCell, "table" ) ;
 
142
                var colArray = [] ;
 
143
                var tableMap = FCKDragTableHandler._TableMap ;
 
144
                for ( var i = 0 ; i < tableMap.length ; i++ )
 
145
                {
 
146
                        for ( var j = 0 ; j < tableMap[i].length ; j++ )
 
147
                        {
 
148
                                var cell = tableMap[i][j] ;
 
149
                                var width = FCKDragTableHandler._GetCellWidth( table, cell ) ;
 
150
                                var colSpan = isNaN( cell.colSpan) ? 1 : cell.colSpan ;
 
151
                                if ( colArray.length <= j )
 
152
                                        colArray.push( { width : width / colSpan, colSpan : colSpan } ) ;
 
153
                                else
 
154
                                {
 
155
                                        var guessItem = colArray[j] ;
 
156
                                        if ( guessItem.colSpan > colSpan )
 
157
                                        {
 
158
                                                guessItem.width = width / colSpan ;
 
159
                                                guessItem.colSpan = colSpan ;
 
160
                                        }
 
161
                                }
 
162
                        }
 
163
                }
 
164
 
 
165
                // Find out the equivalent column index of the two cells selected for resizing.
 
166
                colIndex = FCKDragTableHandler._GetResizeBarPosition() ;
 
167
 
 
168
                // Note that colIndex must be at least 1 here, so it's safe to subtract 1 from it.
 
169
                colIndex-- ;
 
170
 
 
171
                // Modify the widths in the colArray according to the mouse coordinate delta value.
 
172
                colArray[colIndex].width += deltaX ;
 
173
                colArray[colIndex + 1].width -= deltaX ;
 
174
 
 
175
                // Clear all cell widths, delete all <col> elements from the table.
 
176
                for ( var r = 0 ; r < table.rows.length ; r++ )
 
177
                {
 
178
                        var row = table.rows.item( r ) ;
 
179
                        for ( var c = 0 ; c < row.cells.length ; c++ )
 
180
                        {
 
181
                                var cell = row.cells.item( c ) ;
 
182
                                cell.width = "" ;
 
183
                                cell.style.width = "" ;
 
184
                        }
 
185
                }
 
186
                var colElements = table.getElementsByTagName( "col" ) ;
 
187
                for ( var i = colElements.length - 1 ; i >= 0 ; i-- )
 
188
                        colElements[i].parentNode.removeChild( colElements[i] ) ;
 
189
 
 
190
                // Set new cell widths.
 
191
                var processedCells = [] ;
 
192
                for ( var i = 0 ; i < tableMap.length ; i++ )
 
193
                {
 
194
                        for ( var j = 0 ; j < tableMap[i].length ; j++ )
 
195
                        {
 
196
                                var cell = tableMap[i][j] ;
 
197
                                if ( cell._Processed )
 
198
                                        continue ;
 
199
                                if ( tableMap[i][j-1] != cell )
 
200
                                        cell.width = colArray[j].width ;
 
201
                                else
 
202
                                        cell.width = parseInt( cell.width, 10 ) + parseInt( colArray[j].width, 10 ) ;
 
203
                                if ( tableMap[i][j+1] != cell )
 
204
                                {
 
205
                                        processedCells.push( cell ) ;
 
206
                                        cell._Processed = true ;
 
207
                                }
 
208
                        }
 
209
                }
 
210
                for ( var i = 0 ; i < processedCells.length ; i++ )
 
211
                {
 
212
                        if ( FCKBrowserInfo.IsIE )
 
213
                                processedCells[i].removeAttribute( '_Processed' ) ;
 
214
                        else
 
215
                                delete processedCells[i]._Processed ;
 
216
                }
 
217
 
 
218
                FCKDragTableHandler._LastX = null ;
 
219
        },
 
220
        "_ResizeBarMouseMoveListener" : function( evt )
 
221
        {
 
222
                if ( FCKDragTableHandler._MouseMoveMode == 0 )
 
223
                        return FCKDragTableHandler._MouseFindHandler( FCK, evt ) ;
 
224
                else
 
225
                        return FCKDragTableHandler._MouseDragHandler( FCK, evt ) ;
 
226
        },
 
227
        // Calculate the padding of a table cell.
 
228
        // It returns the value of paddingLeft + paddingRight of a table cell.
 
229
        // This function is used, in part, to calculate the width parameter that should be used for setting cell widths.
 
230
        // The equation in question is clientWidth = paddingLeft + paddingRight + width.
 
231
        // So that width = clientWidth - paddingLeft - paddingRight.
 
232
        // The return value of this function must be pixel accurate acorss all supported browsers, so be careful if you need to modify it.
 
233
        "_GetCellPadding" : function( table, cell )
 
234
        {
 
235
                var attrGuess = parseInt( table.cellPadding, 10 ) * 2 ;
 
236
                var cssGuess = null ;
 
237
                if ( typeof( window.getComputedStyle ) == "function" )
 
238
                {
 
239
                        var styleObj = window.getComputedStyle( cell, null ) ;
 
240
                        cssGuess = parseInt( styleObj.getPropertyValue( "padding-left" ), 10 ) +
 
241
                                parseInt( styleObj.getPropertyValue( "padding-right" ), 10 ) ;
 
242
                }
 
243
                else
 
244
                        cssGuess = parseInt( cell.currentStyle.paddingLeft, 10 ) + parseInt (cell.currentStyle.paddingRight, 10 ) ;
 
245
 
 
246
                var cssRuntime = cell.style.padding ;
 
247
                if ( isFinite( cssRuntime ) )
 
248
                        cssGuess = parseInt( cssRuntime, 10 ) * 2 ;
 
249
                else
 
250
                {
 
251
                        cssRuntime = cell.style.paddingLeft ;
 
252
                        if ( isFinite( cssRuntime ) )
 
253
                                cssGuess = parseInt( cssRuntime, 10 ) ;
 
254
                        cssRuntime = cell.style.paddingRight ;
 
255
                        if ( isFinite( cssRuntime ) )
 
256
                                cssGuess += parseInt( cssRuntime, 10 ) ;
 
257
                }
 
258
 
 
259
                attrGuess = parseInt( attrGuess, 10 ) ;
 
260
                cssGuess = parseInt( cssGuess, 10 ) ;
 
261
                if ( isNaN( attrGuess ) )
 
262
                        attrGuess = 0 ;
 
263
                if ( isNaN( cssGuess ) )
 
264
                        cssGuess = 0 ;
 
265
                return Math.max( attrGuess, cssGuess ) ;
 
266
        },
 
267
        // Calculate the real width of the table cell.
 
268
        // The real width of the table cell is the pixel width that you can set to the width attribute of the table cell and after
 
269
        // that, the table cell should be of exactly the same width as before.
 
270
        // The real width of a table cell can be calculated as:
 
271
        // width = clientWidth - paddingLeft - paddingRight.
 
272
        "_GetCellWidth" : function( table, cell )
 
273
        {
 
274
                var clientWidth = cell.clientWidth ;
 
275
                if ( isNaN( clientWidth ) )
 
276
                        clientWidth = 0 ;
 
277
                return clientWidth - this._GetCellPadding( table, cell ) ;
 
278
        },
 
279
        "MouseMoveListener" : function( FCK, evt )
 
280
        {
 
281
                if ( FCKDragTableHandler._MouseMoveMode == 0 )
 
282
                        return FCKDragTableHandler._MouseFindHandler( FCK, evt ) ;
 
283
                else
 
284
                        return FCKDragTableHandler._MouseDragHandler( FCK, evt ) ;
 
285
        },
 
286
        "_MouseFindHandler" : function( FCK, evt )
 
287
        {
 
288
                if ( FCK.MouseDownFlag )
 
289
                        return ;
 
290
                var node = evt.srcElement || evt.target ;
 
291
                try
 
292
                {
 
293
                        if ( ! node || node.nodeType != 1 )
 
294
                        {
 
295
                                this._HideResizeBar() ;
 
296
                                return ;
 
297
                        }
 
298
                }
 
299
                catch ( e )
 
300
                {
 
301
                        this._HideResizeBar() ;
 
302
                        return ;
 
303
                }
 
304
 
 
305
                // Since this function might be called from the editing area iframe or the outer fckeditor iframe,
 
306
                // the mouse point coordinates from evt.clientX/Y can have different reference points.
 
307
                // We need to resolve the mouse pointer position relative to the editing area iframe.
 
308
                var mouseX = evt.clientX ;
 
309
                var mouseY = evt.clientY ;
 
310
                if ( FCKTools.GetElementDocument( node ) == document )
 
311
                {
 
312
                        var offset = this._GetIframeOffset() ;
 
313
                        mouseX -= offset.x ;
 
314
                        mouseY -= offset.y ;
 
315
                }
 
316
 
 
317
 
 
318
                if ( this._ResizeBar && this._LeftCell )
 
319
                {
 
320
                        var leftPos = FCKTools.GetWindowPosition( FCK.EditorWindow, this._LeftCell ) ;
 
321
                        var rightPos = FCKTools.GetWindowPosition( FCK.EditorWindow, this._RightCell ) ;
 
322
                        var rxDist = mouseX - ( leftPos.x + this._LeftCell.clientWidth ) ;
 
323
                        var lxDist = mouseX - rightPos.x ;
 
324
                        var inRangeFlag = false ;
 
325
                        if ( lxDist >= 0 && rxDist <= 0 )
 
326
                                inRangeFlag = true ;
 
327
                        else if ( rxDist > 0 && lxDist <= 3 )
 
328
                                inRangeFlag = true ;
 
329
                        else if ( lxDist < 0 && rxDist >= -2 )
 
330
                                inRangeFlag = true ;
 
331
                        if ( inRangeFlag )
 
332
                        {
 
333
                                this._ShowResizeBar( FCK.EditorWindow,
 
334
                                        FCKTools.GetElementAscensor( this._LeftCell, "table" ),
 
335
                                        { "x" : mouseX, "y" : mouseY } ) ;
 
336
                                return ;
 
337
                        }
 
338
                }
 
339
 
 
340
                var tagName = node.tagName.toLowerCase() ;
 
341
                if ( tagName != "table" && tagName != "td" && tagName != "th" )
 
342
                {
 
343
                        if ( this._LeftCell )
 
344
                                this._LeftCell = this._RightCell = this._TableMap = null ;
 
345
                        this._HideResizeBar() ;
 
346
                        return ;
 
347
                }
 
348
                node = FCKTools.GetElementAscensor( node, "table" ) ;
 
349
                var tableMap = FCKTableHandler._CreateTableMap( node ) ;
 
350
                var cellTuple = this._GetBorderCells( FCK.EditorWindow, node, tableMap, { "x" : mouseX, "y" : mouseY } ) ;
 
351
 
 
352
                if ( cellTuple == null )
 
353
                {
 
354
                        if ( this._LeftCell )
 
355
                                this._LeftCell = this._RightCell = this._TableMap = null ;
 
356
                        this._HideResizeBar() ;
 
357
                }
 
358
                else
 
359
                {
 
360
                        this._LeftCell = cellTuple["leftCell"] ;
 
361
                        this._RightCell = cellTuple["rightCell"] ;
 
362
                        this._TableMap = tableMap ;
 
363
                        this._ShowResizeBar( FCK.EditorWindow,
 
364
                                        FCKTools.GetElementAscensor( this._LeftCell, "table" ),
 
365
                                        { "x" : mouseX, "y" : mouseY } ) ;
 
366
                }
 
367
        },
 
368
        "_MouseDragHandler" : function( FCK, evt )
 
369
        {
 
370
                var mouse = { "x" : evt.clientX, "y" : evt.clientY } ;
 
371
 
 
372
                // Convert mouse coordinates in reference to the outer iframe.
 
373
                var node = evt.srcElement || evt.target ;
 
374
                if ( FCKTools.GetElementDocument( node ) == FCK.EditorDocument )
 
375
                {
 
376
                        var offset = this._GetIframeOffset() ;
 
377
                        mouse.x += offset.x ;
 
378
                        mouse.y += offset.y ;
 
379
                }
 
380
 
 
381
                // Calculate the mouse position delta and see if we've gone out of range.
 
382
                if ( mouse.x >= this._MaximumX - 5 )
 
383
                        mouse.x = this._MaximumX - 5 ;
 
384
                if ( mouse.x <= this._MinimumX + 5 )
 
385
                        mouse.x = this._MinimumX + 5 ;
 
386
 
 
387
                var docX = mouse.x + FCKTools.GetScrollPosition( window ).X ;
 
388
                this._ResizeBar.style.left = ( docX - this._ResizeBar.offsetWidth / 2 ) + "px" ;
 
389
                this._LastX = mouse.x ;
 
390
        },
 
391
        "_ShowResizeBar" : function( w, table, mouse )
 
392
        {
 
393
                if ( this._ResizeBar == null )
 
394
                {
 
395
                        this._ResizeBar = this._doc.createElement( "div" ) ;
 
396
                        var paddingBar = this._ResizeBar ;
 
397
                        var paddingStyles = { 'position' : 'absolute', 'cursor' : 'e-resize' } ;
 
398
                        if ( FCKBrowserInfo.IsIE )
 
399
                                paddingStyles.filter = "progid:DXImageTransform.Microsoft.Alpha(opacity=10,enabled=true)" ;
 
400
                        else
 
401
                                paddingStyles.opacity = 0.10 ;
 
402
                        FCKDomTools.SetElementStyles( paddingBar, paddingStyles ) ;
 
403
                        this._avoidStyles( paddingBar );
 
404
                        paddingBar.setAttribute('_fcktemp', true);
 
405
                        this._doc.body.appendChild( paddingBar ) ;
 
406
                        FCKTools.AddEventListener( paddingBar, "mousemove", this._ResizeBarMouseMoveListener ) ;
 
407
                        FCKTools.AddEventListener( paddingBar, "mousedown", this._ResizeBarMouseDownListener ) ;
 
408
                        FCKTools.AddEventListener( document, "mouseup", this._ResizeBarMouseUpListener ) ;
 
409
                        FCKTools.AddEventListener( FCK.EditorDocument, "mouseup", this._ResizeBarMouseUpListener ) ;
 
410
 
 
411
                        // IE doesn't let the tranparent part of the padding block to receive mouse events unless there's something inside.
 
412
                        // So we need to create a spacer image to fill the block up.
 
413
                        var filler = this._doc.createElement( "img" ) ;
 
414
                        filler.setAttribute('_fcktemp', true);
 
415
                        filler.border = 0 ;
 
416
                        filler.src = FCKConfig.BasePath + "images/spacer.gif" ;
 
417
                        filler.style.position = "absolute" ;
 
418
                        paddingBar.appendChild( filler ) ;
 
419
 
 
420
                        // Disable drag and drop, and selection for the filler image.
 
421
                        var disabledListener = function( evt )
 
422
                        {
 
423
                                if ( evt.preventDefault )
 
424
                                        evt.preventDefault() ;
 
425
                                else
 
426
                                        evt.returnValue = false ;
 
427
                        }
 
428
                        FCKTools.AddEventListener( filler, "dragstart", disabledListener ) ;
 
429
                        FCKTools.AddEventListener( filler, "selectstart", disabledListener ) ;
 
430
                }
 
431
 
 
432
                var paddingBar = this._ResizeBar ;
 
433
                var offset = this._GetIframeOffset() ;
 
434
                var tablePos = this._GetTablePosition( w, table ) ;
 
435
                var barHeight = table.offsetHeight ;
 
436
                var barTop = offset.y + tablePos.y ;
 
437
                // Do not let the resize bar intrude into the toolbar area.
 
438
                if ( tablePos.y < 0 )
 
439
                {
 
440
                        barHeight += tablePos.y ;
 
441
                        barTop -= tablePos.y ;
 
442
                }
 
443
                var bw = parseInt( table.border, 10 ) ;
 
444
                if ( isNaN( bw ) )
 
445
                        bw = 0 ;
 
446
                var cs = parseInt( table.cellSpacing, 10 ) ;
 
447
                if ( isNaN( cs ) )
 
448
                        cs = 0 ;
 
449
                var barWidth = Math.max( bw+100, cs+100 ) ;
 
450
                var paddingStyles =
 
451
                {
 
452
                        'top'           : barTop + 'px',
 
453
                        'height'        : barHeight + 'px',
 
454
                        'width'         : barWidth + 'px',
 
455
                        'left'          : ( offset.x + mouse.x + FCKTools.GetScrollPosition( w ).X - barWidth / 2 ) + 'px'
 
456
                } ;
 
457
                if ( FCKBrowserInfo.IsIE )
 
458
                        paddingBar.filters.item("DXImageTransform.Microsoft.Alpha").opacity = 10 ;
 
459
                else
 
460
                        paddingStyles.opacity = 0.1 ;
 
461
 
 
462
                FCKDomTools.SetElementStyles( paddingBar, paddingStyles ) ;
 
463
                var filler = paddingBar.getElementsByTagName( "img" )[0] ;
 
464
 
 
465
                FCKDomTools.SetElementStyles( filler,
 
466
                        {
 
467
                                width   : paddingBar.offsetWidth + 'px',
 
468
                                height  : barHeight + 'px'
 
469
                        } ) ;
 
470
 
 
471
                barWidth = Math.max( bw, cs, 3 ) ;
 
472
                var visibleBar = null ;
 
473
                if ( paddingBar.getElementsByTagName( "div" ).length < 1 )
 
474
                {
 
475
                        visibleBar = this._doc.createElement( "div" ) ;
 
476
                        this._avoidStyles( visibleBar );
 
477
                        visibleBar.setAttribute('_fcktemp', true);
 
478
                        paddingBar.appendChild( visibleBar ) ;
 
479
                }
 
480
                else
 
481
                        visibleBar = paddingBar.getElementsByTagName( "div" )[0] ;
 
482
 
 
483
                FCKDomTools.SetElementStyles( visibleBar,
 
484
                        {
 
485
                                position                : 'absolute',
 
486
                                backgroundColor : 'blue',
 
487
                                width                   : barWidth + 'px',
 
488
                                height                  : barHeight + 'px',
 
489
                                left                    : '50px',
 
490
                                top                             : '0px'
 
491
                        } ) ;
 
492
        },
 
493
        "_HideResizeBar" : function()
 
494
        {
 
495
                if ( this._ResizeBar )
 
496
                        // IE bug: display : none does not hide the resize bar for some reason.
 
497
                        // so set the position to somewhere invisible.
 
498
                        FCKDomTools.SetElementStyles( this._ResizeBar,
 
499
                                {
 
500
                                        top             : '-100000px',
 
501
                                        left    : '-100000px'
 
502
                                } ) ;
 
503
        },
 
504
        "_GetIframeOffset" : function ()
 
505
        {
 
506
                return FCKTools.GetDocumentPosition( window, FCK.EditingArea.IFrame ) ;
 
507
        },
 
508
        "_GetTablePosition" : function ( w, table )
 
509
        {
 
510
                return FCKTools.GetWindowPosition( w, table ) ;
 
511
        },
 
512
        "_avoidStyles" : function( element )
 
513
        {
 
514
                FCKDomTools.SetElementStyles( element,
 
515
                        {
 
516
                                padding         : '0',
 
517
                                backgroundImage : 'none',
 
518
                                border          : '0'
 
519
                        } ) ;
 
520
        }
 
521
 
 
522
};
 
523
 
 
524
FCK.Events.AttachEvent( "OnMouseMove", FCKDragTableHandler.MouseMoveListener ) ;