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     // need to reset default size after changing m_gdkDecor
 370     gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);
 371
 372     if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)))
 373     {
 374         gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
 375     }
 376
 377     if ((style & wxCLOSE_BOX) &&
 378         ((style & wxCAPTION) || (style & wxTINY_CAPTION_HORIZ) || (style & wxTINY_CAPTION_VERT)))
 379     {
 380         wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage();
 381         img.Replace(0,0,0,123,123,123);
 382         img.SetMaskColour(123,123,123);
 383         m_closeButton = wxBitmap( img );
 384     }
 385
 386     /* these are called when the borders are drawn */
 387     g_signal_connect_after(fixed, "expose_event",
 388                       G_CALLBACK (gtk_window_own_expose_callback), this );
 389
 390     /* these are required for dragging the mini frame around */
 391     g_signal_connect (fixed, "button_press_event",
 392                       G_CALLBACK (gtk_window_button_press_callback), this);
 393     g_signal_connect (fixed, "button_release_event",
 394                       G_CALLBACK (gtk_window_button_release_callback), this);
 395     g_signal_connect (fixed, "motion_notify_event",
 396                       G_CALLBACK (gtk_window_motion_notify_callback), this);
 397     g_signal_connect (fixed, "leave_notify_event",
 398                       G_CALLBACK (gtk_window_leave_callback), this);
 399     return true;
 400 }
 401
 402 void wxMiniFrame::DoGetClientSize(int* width, int* height) const
 403 {
 404     wxFrame::DoGetClientSize(width, height);
 405     if (width)
 406     {
 407         *width -= 2 * m_miniEdge;
 408         if (*width < 0) *width = 0;
 409     }
 410     if (height)
 411     {
 412         *height -= m_miniTitle + 2 * m_miniEdge;
 413         if (*height < 0) *height = 0;
 414     }
 415 }
 416
 417 void wxMiniFrame::SetTitle( const wxString &title )
 418 {
 419     wxFrame::SetTitle( title );
 420
 421     GtkWidget* fixed = GTK_BIN(m_widget)->child;
 422     if (fixed->window)
 423         gdk_window_invalidate_rect(fixed->window, NULL, false);
 424 }
 425
 426 #endif // wxUSE_MINIFRAME