nf

1 files changed, 9 insertions, 0 deletions

diff --git a/microkde/KDGanttMinimizeSplitter.cpp b/microkde/KDGanttMinimizeSplitter.cpp
index 6cb1f31..253175e 100644
--- a/microkde/KDGanttMinimizeSplitter.cpp
+++ b/microkde/KDGanttMinimizeSplitter.cpp
@@ -146,269 +146,278 @@ void KDGanttSplitterHandle::updateCursor( const QPoint& p)
     }
 }
 void KDGanttSplitterHandle::toggle()
 {
     int pos;
     int min, max;
     if ( !_collapsed ) {
         s->expandPos( id(), &min, &max );
         if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left
              || s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
             pos = min;
         }
         else {
             pos = max;
         }
 
         _origPos = s->pick(mapToParent( QPoint( 0,0 ) ));
         s->moveSplitter( pos, id() );
         _collapsed = true;
     }
     else {
         s->moveSplitter( _origPos, id() );
         _collapsed = false;
     }
     repaint();
 }
 
 void KDGanttSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
 {
     mMouseDown = false;
     if ( _activeButton != 0 ) {
         if ( onButton( e->pos() ) == _activeButton )
         {
             toggle();
         }
         _activeButton = 0;
         updateCursor( e->pos() );
     }
     else {
         if ( !opaque() && e->button() == LeftButton ) {
             QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
                 - mouseOffset;
             s->setRubberband( -1 );
             s->moveSplitter( pos, id() );
         }
     }
     if ( s->rubberBand() )
         s->rubberBand()->hide();
     repaint();
 }
 
 int KDGanttSplitterHandle::onButton( const QPoint& p )
 {
     QValueList<QPointArray> list = buttonRegions();
     int index = 1;
     int add = 12;
     for( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
         QRect rect = (*it).boundingRect();
         rect.setLeft( rect.left()- add );
         rect.setRight( rect.right() + add);
         rect.setTop( rect.top()- add );
         rect.setBottom( rect.bottom() + add);
         if ( rect.contains( p ) ) {
             return index;
         }
         index++;
     }
     return 0;
 }
 
 
 QValueList<QPointArray> KDGanttSplitterHandle::buttonRegions()
 {
     QValueList<QPointArray> list;
 
     int sw = 8;
     int yyy = 1;
     int xxx = 1;
     int voffset[] = { (int) -sw*3, (int) sw*3 };
     for ( int i = 0; i < 2; i++ ) {
         QPointArray arr;
         if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ||
              _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Left) {
             int mid = height()/2 + voffset[i];
             arr.setPoints( 3,
                            1-xxx, mid - sw + 4,
                            sw-3-xxx, mid,
                            1-xxx, mid + sw -4);
         }
         else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
             int mid = height()/2 + voffset[i];
             arr.setPoints( 3,
                            sw-4, mid - sw + 4,
                            0, mid,
                            sw-4, mid + sw - 4);
         }
         else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Down) {
             int mid = width()/2 + voffset[i];
             arr.setPoints( 3,
                            mid - sw + 4, sw-4,
                            mid, 0,
                            mid + sw - 4, sw-4 );
         }
         else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
             int mid = width()/2 + voffset[i];
             arr.setPoints( 3,
                            mid - sw + 4, 1-yyy,
                            mid, sw-3-yyy,
                            mid + sw -4, 1-yyy);
         }
         list.append( arr );
     }
     return list;
 }
 
 void KDGanttSplitterHandle::paintEvent( QPaintEvent * )
 {
     QPixmap buffer( size() );
     QPainter p( &buffer );
 
     //LR
     // Draw the splitter rectangle
     p.setBrush( colorGroup().background() );
     p.setPen( colorGroup().foreground() );
     //p.drawRect( rect() );
+#ifndef DESKTOP_VERSION
+    if (  mMouseDown )
+        buffer.fill( QColor( 242,27,255  ) );
+    else    
+#endif
     buffer.fill( colorGroup().background() );
     //buffer.fill( backgroundColor() );
     // parentWidget()->style().drawPrimitive( QStyle::PE_Panel, &p, rect(), parentWidget()->colorGroup());
 
     int sw = 8; // Hardcoded, given I didn't use styles anymore, I didn't like to use their size
 
     // arrow color
     QColor col;
     if ( _activeButton )
         col = colorGroup().background().dark( 250 );
     else {
         if ( mMouseDown )
+#ifndef DESKTOP_VERSION
+            col =  QColor( 178,18,188);//QColor( 242,27,255  );//Qt::white; 
+#else
             col = Qt::white;
+#endif
         else
             col = colorGroup().background().dark( 150 );
     }
     //QColor col = backgroundColor().dark( 130 );
     p.setBrush( col );
     p.setPen( col  );
 
     QValueList<QPointArray> list = buttonRegions();
     int index = 1;
     if ( mUseOffset )
         p.translate( 0, 1 );
     for ( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
         if ( index == _activeButton ) { 
            
             /*
             if ( ! _collapsed ) {
             p.save();
             // p.translate( parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftHorizontal ),
             //           parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftVertical ) );
             p.translate( -1, 0 );
             p.drawPolygon( *it, true );
             p.restore(); } else
             */
             p.drawPolygon( *it, true );
                 
         }
         else {
             /*
             if ( ! _collapsed ) {
             p.save();
             p.translate( -1, 0 );
             p.drawPolygon( *it, true );
             p.restore();
             } else
             */
             p.drawPolygon( *it, true );
                 
         }
         index++;
     }
 
     // Draw the lines between the arrows
     if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
          s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
         int mid = height()/2;
         p.drawLine ( 1, mid - sw, 1, mid + sw );
         p.drawLine ( 3, mid - sw, 3, mid + sw );
     }
     else if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
               s->minimizeDirection() == KDGanttMinimizeSplitter::Down ) {
         int mid = width()/2;
         p.drawLine( mid -sw, 1, mid +sw, 1 );
         p.drawLine( mid -sw, 3, mid +sw, 3 );
     }
     bitBlt( this, 0, 0, &buffer );
 
 }
 #endif
 
 class QSplitterLayoutStruct
 {
 public:
     KDGanttMinimizeSplitter::ResizeMode mode;
     QCOORD sizer;
     bool isSplitter;
     QWidget *wid;
 };
 
 class QSplitterData
 {
 public:
     QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}
 
     QPtrList<QSplitterLayoutStruct> list;
     bool opaque;
     bool firstShow;
 };
 
 void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
                  int space, int spacer );
 #endif // DOXYGEN_SKIP_INTERNAL
 
 
 /*!
   \class KDGanttMinimizeSplitter KDGanttMinimizeSplitter.h
   \brief The KDGanttMinimizeSplitter class implements a splitter
   widget with minimize buttons.
 
   This class (and its documentation) is largely a copy of Qt's
   QSplitter; the copying was necessary because QSplitter is not
   extensible at all. QSplitter and its documentation are licensed
   according to the GPL and the Qt Professional License (if you hold
   such a license) and are (C) Trolltech AS.
 
   A splitter lets the user control the size of child widgets by
   dragging the boundary between the children. Any number of widgets
   may be controlled.
 
   To show a QListBox, a QListView and a QTextEdit side by side:
 
   \code
     KDGanttMinimizeSplitter *split = new KDGanttMinimizeSplitter( parent );
     QListBox *lb = new QListBox( split );
     QListView *lv = new QListView( split );
     QTextEdit *ed = new QTextEdit( split );
   \endcode
 
   In KDGanttMinimizeSplitter, the boundary can be either horizontal or
   vertical.  The default is horizontal (the children are side by side)
   but you can use setOrientation( QSplitter::Vertical ) to set it to
   vertical.
 
   Use setResizeMode() to specify
   that a widget should keep its size when the splitter is resized.
 
   Although KDGanttMinimizeSplitter normally resizes the children only
   at the end of a resize operation, if you call setOpaqueResize( TRUE
   ) the widgets are resized as often as possible.
 
   The initial distribution of size between the widgets is determined
   by the initial size of each widget. You can also use setSizes() to
   set the sizes of all the widgets. The function sizes() returns the
   sizes set by the user.
 
   If you hide() a child, its space will be distributed among the other
   children. It will be reinstated when you show() it again. It is also
   possible to reorder the widgets within the splitter using
   moveToFirst() and moveToLast().