src/gtk/minifram.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/minifram.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_MINIFRAME
  14
  15 #include "wx/minifram.h"
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/settings.h"
  19     #include "wx/dcclient.h"
  20     #include "wx/image.h"
  21 #endif
  22
  23 #include <gtk/gtk.h>
  24
  25 //-----------------------------------------------------------------------------
  26 // data
  27 //-----------------------------------------------------------------------------
  28
  29 extern bool        g_blockEventsOnDrag;
  30 extern bool        g_blockEventsOnScroll;
  31
  32 //-----------------------------------------------------------------------------
  33 // "expose_event" of m_mainWidget
  34 //-----------------------------------------------------------------------------
  35
  36 // StepColour() it a utility function that simply darkens
  37 // or lightens a color, based on the specified percentage
  38 static wxColor StepColour(const wxColor& c, int percent)
  39 {
  40     int r = c.Red(), g = c.Green(), b = c.Blue();
  41     return wxColour((unsigned char)wxMin((r*percent)/100,255),
  42                     (unsigned char)wxMin((g*percent)/100,255),
  43                     (unsigned char)wxMin((b*percent)/100,255));
  44 }
  45
  46 static wxColor LightContrastColour(const wxColour& c)
  47 {
  48     int amount = 120;
  49
  50     // if the color is especially dark, then
  51     // make the contrast even lighter
  52     if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
  53         amount = 160;
  54
  55     return StepColour(c, amount);
  56 }
  57
  58 extern "C" {
  59 static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
  60 {
  61     if (!win->m_hasVMT || gdk_event->count > 0)
  62         return false;
  63
  64     gtk_paint_shadow (widget->style,
  65                       widget->window,
  66                       GTK_STATE_NORMAL,
  67                       GTK_SHADOW_OUT,
  68                       NULL, NULL, NULL, // FIXME: No clipping?
  69                       0, 0,
  70                       win->m_width, win->m_height);
  71
  72     int style = win->GetWindowStyle();
  73
  74     wxClientDC dc(win);
  75
  76 #if wxUSE_NEW_DC
  77     wxImplDC *impl = dc.GetImpl();
  78     wxGTKClientImplDC *client_impl = wxDynamicCast( impl, wxGTKClientImplDC );
  79     // Hack alert
  80     client_impl->m_window = widget->window;
  81 #else
  82     // Hack alert
  83     dc.m_window = widget->window;
  84 #endif
  85
  86     if (style & wxRESIZE_BORDER)
  87     {
  88         dc.SetBrush( *wxGREY_BRUSH );
  89         dc.SetPen( *wxTRANSPARENT_PEN );
  90         dc.DrawRectangle( win->m_width - 14, win->m_height-14, 14, 14 );
  91     }
  92
  93     if (!win->GetTitle().empty() &&
  94         ((style & wxCAPTION) ||
  95          (style & wxTINY_CAPTION_HORIZ) ||
  96          (style & wxTINY_CAPTION_VERT)))
  97     {
  98         dc.SetFont( *wxSMALL_FONT );
  99
 100         wxBrush brush( LightContrastColour( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT) ) );
 101         dc.SetBrush( brush );
 102         dc.SetPen( *wxTRANSPARENT_PEN );
 103         dc.DrawRectangle( win->m_miniEdge-1,
 104                           win->m_miniEdge-1,
 105                           win->m_width - (2*(win->m_miniEdge-1)),
 106                           15  );
 107
 108         dc.SetTextForeground( *wxWHITE );
 109         dc.DrawText( win->GetTitle(), 6, 4 );
 110
 111         if (style & wxCLOSE_BOX)
 112             dc.DrawBitmap( win->m_closeButton, win->m_width-18, 3, true );
 113     }
 114
 115     return false;
 116 }
 117 }
 118
 119 //-----------------------------------------------------------------------------
 120 // "button_press_event" of m_mainWidget
 121 //-----------------------------------------------------------------------------
 122
 123 extern "C" {
 124 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxMiniFrame *win )
 125 {
 126     if (!win->m_hasVMT) return FALSE;
 127     if (g_blockEventsOnDrag) return TRUE;
 128     if (g_blockEventsOnScroll) return TRUE;
 129
 130     if (win->m_isDragging) return TRUE;
 131
 132     int style = win->GetWindowStyle();
 133
 134     int y = (int)gdk_event->y;
 135     int x = (int)gdk_event->x;
 136
 137     if ((style & wxRESIZE_BORDER) &&
 138         (x > win->m_width-14) && (y > win->m_height-14))
 139     {
 140         GtkWidget *ancestor = gtk_widget_get_toplevel( widget );
 141
 142         GdkWindow *source = widget->window;
 143
 144         int org_x = 0;
 145         int org_y = 0;
 146         gdk_window_get_origin( source, &org_x, &org_y );
 147
 148         gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
 149                                   GDK_WINDOW_EDGE_SOUTH_EAST,
 150                                   1,
 151                                   org_x + x,
 152                                   org_y + y,
 153                                   0);
 154
 155         return TRUE;
 156     }
 157
 158     if ((style & wxCLOSE_BOX) &&
 159         ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT)))
 160     {
 161         if ((y > 3) && (y < 19) && (x > win->m_width-19) && (x < win->m_width-3))
 162         {
 163             win->Close();
 164             return TRUE;
 165         }
 166     }
 167
 168     if (y > win->m_miniEdge-1 + 15) return TRUE;
 169
 170     gdk_window_raise( win->m_widget->window );
 171
 172     gdk_pointer_grab( widget->window, FALSE,
 173                       (GdkEventMask)
 174                          (GDK_BUTTON_PRESS_MASK |
 175                           GDK_BUTTON_RELEASE_MASK |
 176                           GDK_POINTER_MOTION_MASK        |
 177                           GDK_POINTER_MOTION_HINT_MASK  |
 178                           GDK_BUTTON_MOTION_MASK        |
 179                           GDK_BUTTON1_MOTION_MASK),
 180                       (GdkWindow *) NULL,
 181                       (GdkCursor *) NULL,
 182                       (unsigned int) GDK_CURRENT_TIME );
 183
 184     win->m_diffX = x;
 185     win->m_diffY = y;
 186     win->m_oldX = 0;
 187     win->m_oldY = 0;
 188
 189     win->m_isDragging = true;
 190
 191     return TRUE;
 192 }
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 // "button_release_event" of m_mainWidget
 197 //-----------------------------------------------------------------------------
 198
 199 extern "C" {
 200 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxMiniFrame *win )
 201 {
 202     if (!win->m_hasVMT) return FALSE;
 203     if (g_blockEventsOnDrag) return TRUE;
 204     if (g_blockEventsOnScroll) return TRUE;
 205
 206     if (!win->m_isDragging) return TRUE;
 207
 208     win->m_isDragging = false;
 209
 210     int x = (int)gdk_event->x;
 211     int y = (int)gdk_event->y;
 212
 213     gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
 214     int org_x = 0;
 215     int org_y = 0;
 216     gdk_window_get_origin( widget->window, &org_x, &org_y );
 217     x += org_x - win->m_diffX;
 218     y += org_y - win->m_diffY;
 219     win->m_x = x;
 220     win->m_y = y;
 221     gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
 222
 223     return TRUE;
 224 }
 225 }
 226
 227 //-----------------------------------------------------------------------------
 228 // "leave_notify_event" of m_mainWidget
 229 //-----------------------------------------------------------------------------
 230
 231 extern "C" {
 232 static gboolean
 233 gtk_window_leave_callback(GtkWidget *widget,
 234                           GdkEventCrossing * WXUNUSED(gdk_event),
 235                           wxMiniFrame *win)
 236 {
 237     if (!win->m_hasVMT) return FALSE;
 238     if (g_blockEventsOnDrag) return FALSE;
 239
 240     gdk_window_set_cursor( widget->window, NULL );
 241
 242     return FALSE;
 243 }
 244 }
 245
 246 //-----------------------------------------------------------------------------
 247 // "motion_notify_event" of m_mainWidget
 248 //-----------------------------------------------------------------------------
 249
 250 extern "C" {
 251 static gint
 252 gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
 253 {
 254     if (!win->m_hasVMT) return FALSE;
 255     if (g_blockEventsOnDrag) return TRUE;
 256     if (g_blockEventsOnScroll) return TRUE;
 257
 258     if (gdk_event->is_hint)
 259     {
 260        int x = 0;
 261        int y = 0;
 262        GdkModifierType state;
 263        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 264        gdk_event->x = x;
 265        gdk_event->y = y;
 266        gdk_event->state = state;
 267     }
 268
 269     int style = win->GetWindowStyle();
 270
 271     int x = (int)gdk_event->x;
 272     int y = (int)gdk_event->y;
 273
 274     if (!win->m_isDragging)
 275     {
 276         if (style & wxRESIZE_BORDER)
 277         {
 278             if ((x > win->m_width-14) && (y > win->m_height-14))
 279                gdk_window_set_cursor( widget->window, gdk_cursor_new( GDK_BOTTOM_RIGHT_CORNER ) );
 280             else
 281                gdk_window_set_cursor( widget->window, NULL );
 282         }
 283         return TRUE;
 284     }
 285
 286     win->m_oldX = x - win->m_diffX;
 287     win->m_oldY = y - win->m_diffY;
 288
 289     int org_x = 0;
 290     int org_y = 0;
 291     gdk_window_get_origin( widget->window, &org_x, &org_y );
 292     x += org_x - win->m_diffX;
 293     y += org_y - win->m_diffY;
 294     win->m_x = x;
 295     win->m_y = y;
 296     gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
 297
 298     return TRUE;
 299 }
 300 }
 301
 302 //-----------------------------------------------------------------------------
 303 // "size_allocate" from GtkFixed, parent of m_mainWidget
 304 //-----------------------------------------------------------------------------
 305
 306 extern "C" {
 307 static void size_allocate(GtkWidget*, GtkAllocation* alloc, wxMiniFrame* win)
 308 {
 309     // place m_mainWidget inside of decorations drawn on the GtkFixed
 310     GtkAllocation alloc2 = win->m_mainWidget->allocation;
 311     alloc2.width = alloc->width - 2 * win->m_miniEdge;
 312     alloc2.height = alloc->height - win->m_miniTitle - 2 * win->m_miniEdge;
 313     gtk_widget_size_allocate(win->m_mainWidget, &alloc2);
 314 }
 315 }
 316
 317 //-----------------------------------------------------------------------------
 318 // wxMiniFrame
 319 //-----------------------------------------------------------------------------
 320
 321 static unsigned char close_bits[]={
 322     0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
 323     0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
 324     0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 325
 326
 327 IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame,wxFrame)
 328
 329 bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
 330       const wxPoint &pos, const wxSize &size,
 331       long style, const wxString &name )
 332 {
 333     if ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT))
 334         m_miniTitle = 16;
 335
 336     if (style & wxRESIZE_BORDER)
 337         m_miniEdge = 4;
 338     else
 339         m_miniEdge = 3;
 340     m_isDragging = false;
 341     m_oldX = -1;
 342     m_oldY = -1;
 343     m_diffX = 0;
 344     m_diffY = 0;
 345
 346     wxFrame::Create( parent, id, title, pos, size, style, name );
 347
 348     // borders and title are on a GtkFixed between m_widget and m_mainWidget
 349     GtkWidget* fixed = gtk_fixed_new();
 350     gtk_fixed_set_has_window((GtkFixed*)fixed, true);
 351     gtk_widget_add_events(fixed,
 352         GDK_POINTER_MOTION_MASK |
 353         GDK_POINTER_MOTION_HINT_MASK |
 354         GDK_BUTTON_MOTION_MASK |
 355         GDK_BUTTON_PRESS_MASK |
 356         GDK_BUTTON_RELEASE_MASK |
 357         GDK_LEAVE_NOTIFY_MASK);
 358     gtk_widget_show(fixed);
 359     gtk_widget_reparent(m_mainWidget, fixed);
 360     gtk_container_add((GtkContainer*)m_widget, fixed);
 361     gtk_fixed_move((GtkFixed*)fixed, m_mainWidget, m_miniEdge, m_miniTitle + m_miniEdge);
 362     g_signal_connect(fixed, "size_allocate", G_CALLBACK(size_allocate), this);
 363
 364     m_gdkDecor = 0;
 365     m_gdkFunc = 0;
 366     if (style & wxRESIZE_BORDER)
 367        m_gdkFunc = GDK_FUNC_RESIZE;
 368
 369     if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)))
 370     {
 371         gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
 372     }
 373
 374     if ((style & wxCLOSE_BOX) &&
 375         ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT)))
 376     {
 377         wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage();
 378         img.Replace(0,0,0,123,123,123);
 379         img.SetMaskColour(123,123,123);
 380         m_closeButton = wxBitmap( img );
 381     }
 382
 383     /* these are called when the borders are drawn */
 384     g_signal_connect_after(fixed, "expose_event",
 385                       G_CALLBACK (gtk_window_own_expose_callback), this );
 386
 387     /* these are required for dragging the mini frame around */
 388     g_signal_connect (fixed, "button_press_event",
 389                       G_CALLBACK (gtk_window_button_press_callback), this);
 390     g_signal_connect (fixed, "button_release_event",
 391                       G_CALLBACK (gtk_window_button_release_callback), this);
 392     g_signal_connect (fixed, "motion_notify_event",
 393                       G_CALLBACK (gtk_window_motion_notify_callback), this);
 394     g_signal_connect (fixed, "leave_notify_event",
 395                       G_CALLBACK (gtk_window_leave_callback), this);
 396     return true;
 397 }
 398
 399 void wxMiniFrame::DoGetClientSize(int* width, int* height) const
 400 {
 401     wxFrame::DoGetClientSize(width, height);
 402     if (width)
 403     {
 404         *width -= 2 * m_miniEdge;
 405         if (*width < 0) *width = 0;
 406     }
 407     if (height)
 408     {
 409         *height -= m_miniTitle + 2 * m_miniEdge;
 410         if (*height < 0) *height = 0;
 411     }
 412 }
 413
 414 void wxMiniFrame::SetTitle( const wxString &title )
 415 {
 416     wxFrame::SetTitle( title );
 417
 418     GtkWidget* fixed = GTK_BIN(m_widget)->child;
 419     if (fixed->window)
 420         gdk_window_invalidate_rect(fixed->window, NULL, false);
 421 }
 422
 423 #endif // wxUSE_MINIFRAME