gntwidget.c

   1 /**
   2  * GNT - The GLib Ncurses Toolkit
   3  *
   4  * GNT is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This library is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22
  23 /* Stuff brutally ripped from Gflib */
  24
  25 #include "gntwidget.h"
  26 #include "gntstyle.h"
  27 #include "gntmarshal.h"
  28 #include "gntutils.h"
  29 #include "gnt.h"
  30
  31 enum
  32 {
  33         SIG_DESTROY,
  34         SIG_DRAW,
  35         SIG_HIDE,
  36         SIG_GIVE_FOCUS,
  37         SIG_LOST_FOCUS,
  38         SIG_KEY_PRESSED,
  39         SIG_MAP,
  40         SIG_ACTIVATE,
  41         SIG_EXPOSE,
  42         SIG_SIZE_REQUEST,
  43         SIG_CONFIRM_SIZE,
  44         SIG_SIZE_CHANGED,
  45         SIG_POSITION,
  46         SIG_CLICKED,
  47         SIG_CONTEXT_MENU,
  48         SIGS
  49 };
  50
  51 static GObjectClass *parent_class = NULL;
  52 static guint signals[SIGS] = { 0 };
  53
  54 static void init_widget(GntWidget *widget);
  55
  56 static void
  57 gnt_widget_init(GTypeInstance *instance, gpointer class)
  58 {
  59         GntWidget *widget = GNT_WIDGET(instance);
  60         widget->priv.name = NULL;
  61         GNTDEBUG;
  62 }
  63
  64 static void
  65 gnt_widget_map(GntWidget *widget)
  66 {
  67         /* Get some default size for the widget */
  68         GNTDEBUG;
  69         g_signal_emit(widget, signals[SIG_MAP], 0);
  70         GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_MAPPED);
  71 }
  72
  73 static void
  74 gnt_widget_dispose(GObject *obj)
  75 {
  76         GntWidget *self = GNT_WIDGET(obj);
  77         g_signal_emit(self, signals[SIG_DESTROY], 0);
  78         parent_class->dispose(obj);
  79         GNTDEBUG;
  80 }
  81
  82 static void
  83 gnt_widget_focus_change(GntWidget *widget)
  84 {
  85         if (GNT_WIDGET_FLAGS(widget) & GNT_WIDGET_MAPPED)
  86                 gnt_widget_draw(widget);
  87 }
  88
  89 static gboolean
  90 gnt_widget_dummy_confirm_size(GntWidget *widget, int width, int height)
  91 {
  92         gboolean shadow;
  93         if (width < widget->priv.minw || height < widget->priv.minh)
  94                 return FALSE;
  95         shadow = gnt_widget_has_shadow(widget);
  96         if (widget->priv.width + shadow != width && !GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_GROW_X))
  97                 return FALSE;
  98         if (widget->priv.height + shadow != height && !GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_GROW_Y))
  99                 return FALSE;
 100         return TRUE;
 101 }
 102
 103 static gboolean
 104 context_menu(GntBindable *bind, GList *null)
 105 {
 106         gboolean ret = FALSE;
 107         g_signal_emit(bind, signals[SIG_CONTEXT_MENU], 0, &ret);
 108         return ret;
 109 }
 110
 111 static void
 112 gnt_widget_class_init(GntWidgetClass *klass)
 113 {
 114         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 115
 116         parent_class = g_type_class_peek_parent(klass);
 117
 118         obj_class->dispose = gnt_widget_dispose;
 119
 120         klass->destroy = gnt_widget_destroy;
 121         klass->show = gnt_widget_show;
 122         klass->draw = gnt_widget_draw;
 123         klass->expose = gnt_widget_expose;
 124         klass->map = gnt_widget_map;
 125         klass->lost_focus = gnt_widget_focus_change;
 126         klass->gained_focus = gnt_widget_focus_change;
 127         klass->confirm_size = gnt_widget_dummy_confirm_size;
 128
 129         klass->key_pressed = NULL;
 130         klass->activate = NULL;
 131         klass->clicked = NULL;
 132
 133         signals[SIG_DESTROY] =
 134                 g_signal_new("destroy",
 135                                          G_TYPE_FROM_CLASS(klass),
 136                                          G_SIGNAL_RUN_LAST,
 137                                          G_STRUCT_OFFSET(GntWidgetClass, destroy),
 138                                          NULL, NULL,
 139                                          g_cclosure_marshal_VOID__VOID,
 140                                          G_TYPE_NONE, 0);
 141         signals[SIG_GIVE_FOCUS] =
 142                 g_signal_new("gained-focus",
 143                                          G_TYPE_FROM_CLASS(klass),
 144                                          G_SIGNAL_RUN_LAST,
 145                                          G_STRUCT_OFFSET(GntWidgetClass, gained_focus),
 146                                          NULL, NULL,
 147                                          g_cclosure_marshal_VOID__VOID,
 148                                          G_TYPE_NONE, 0);
 149         signals[SIG_LOST_FOCUS] =
 150                 g_signal_new("lost-focus",
 151                                          G_TYPE_FROM_CLASS(klass),
 152                                          G_SIGNAL_RUN_LAST,
 153                                          G_STRUCT_OFFSET(GntWidgetClass, lost_focus),
 154                                          NULL, NULL,
 155                                          g_cclosure_marshal_VOID__VOID,
 156                                          G_TYPE_NONE, 0);
 157         signals[SIG_ACTIVATE] =
 158                 g_signal_new("activate",
 159                                          G_TYPE_FROM_CLASS(klass),
 160                                          G_SIGNAL_RUN_LAST,
 161                                          G_STRUCT_OFFSET(GntWidgetClass, activate),
 162                                          NULL, NULL,
 163                                          g_cclosure_marshal_VOID__VOID,
 164                                          G_TYPE_NONE, 0);
 165         signals[SIG_MAP] =
 166                 g_signal_new("map",
 167                                          G_TYPE_FROM_CLASS(klass),
 168                                          G_SIGNAL_RUN_LAST,
 169                                          G_STRUCT_OFFSET(GntWidgetClass, map),
 170                                          NULL, NULL,
 171                                          g_cclosure_marshal_VOID__VOID,
 172                                          G_TYPE_NONE, 0);
 173         signals[SIG_DRAW] =
 174                 g_signal_new("draw",
 175                                          G_TYPE_FROM_CLASS(klass),
 176                                          G_SIGNAL_RUN_LAST,
 177                                          G_STRUCT_OFFSET(GntWidgetClass, draw),
 178                                          NULL, NULL,
 179                                          g_cclosure_marshal_VOID__VOID,
 180                                          G_TYPE_NONE, 0);
 181         signals[SIG_HIDE] =
 182                 g_signal_new("hide",
 183                                          G_TYPE_FROM_CLASS(klass),
 184                                          G_SIGNAL_RUN_LAST,
 185                                          G_STRUCT_OFFSET(GntWidgetClass, hide),
 186                                          NULL, NULL,
 187                                          g_cclosure_marshal_VOID__VOID,
 188                                          G_TYPE_NONE, 0);
 189         signals[SIG_EXPOSE] =
 190                 g_signal_new("expose",
 191                                          G_TYPE_FROM_CLASS(klass),
 192                                          G_SIGNAL_RUN_LAST,
 193                                          G_STRUCT_OFFSET(GntWidgetClass, expose),
 194                                          NULL, NULL,
 195                                          gnt_closure_marshal_VOID__INT_INT_INT_INT,
 196                                          G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
 197         signals[SIG_POSITION] =
 198                 g_signal_new("position-set",
 199                                          G_TYPE_FROM_CLASS(klass),
 200                                          G_SIGNAL_RUN_LAST,
 201                                          G_STRUCT_OFFSET(GntWidgetClass, set_position),
 202                                          NULL, NULL,
 203                                          gnt_closure_marshal_VOID__INT_INT,
 204                                          G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
 205         signals[SIG_SIZE_REQUEST] =
 206                 g_signal_new("size_request",
 207                                          G_TYPE_FROM_CLASS(klass),
 208                                          G_SIGNAL_RUN_LAST,
 209                                          G_STRUCT_OFFSET(GntWidgetClass, size_request),
 210                                          NULL, NULL,
 211                                          g_cclosure_marshal_VOID__VOID,
 212                                          G_TYPE_NONE, 0);
 213         signals[SIG_SIZE_CHANGED] =
 214                 g_signal_new("size_changed",
 215                                          G_TYPE_FROM_CLASS(klass),
 216                                          G_SIGNAL_RUN_LAST,
 217                                          G_STRUCT_OFFSET(GntWidgetClass, size_changed),
 218                                          NULL, NULL,
 219                                          gnt_closure_marshal_VOID__INT_INT,
 220                                          G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
 221         signals[SIG_CONFIRM_SIZE] =
 222                 g_signal_new("confirm_size",
 223                                          G_TYPE_FROM_CLASS(klass),
 224                                          G_SIGNAL_RUN_LAST,
 225                                          G_STRUCT_OFFSET(GntWidgetClass, confirm_size),
 226                                          NULL, NULL,
 227                                          gnt_closure_marshal_BOOLEAN__INT_INT,
 228                                          G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT);
 229         signals[SIG_KEY_PRESSED] =
 230                 g_signal_new("key_pressed",
 231                                          G_TYPE_FROM_CLASS(klass),
 232                                          G_SIGNAL_RUN_LAST,
 233                                          G_STRUCT_OFFSET(GntWidgetClass, key_pressed),
 234                                          gnt_boolean_handled_accumulator, NULL,
 235                                          gnt_closure_marshal_BOOLEAN__STRING,
 236                                          G_TYPE_BOOLEAN, 1, G_TYPE_STRING);
 237
 238         signals[SIG_CLICKED] =
 239                 g_signal_new("clicked",
 240                                          G_TYPE_FROM_CLASS(klass),
 241                                          G_SIGNAL_RUN_LAST,
 242                                          G_STRUCT_OFFSET(GntWidgetClass, clicked),
 243                                          gnt_boolean_handled_accumulator, NULL,
 244                                          gnt_closure_marshal_BOOLEAN__INT_INT_INT,
 245                                          G_TYPE_BOOLEAN, 3, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
 246
 247         signals[SIG_CONTEXT_MENU] =
 248                 g_signal_new("context-menu",
 249                                          G_TYPE_FROM_CLASS(klass),
 250                                          G_SIGNAL_RUN_LAST,
 251                                          0,
 252                                          gnt_boolean_handled_accumulator, NULL,
 253                                          gnt_closure_marshal_BOOLEAN__VOID,
 254                                          G_TYPE_BOOLEAN, 0);
 255
 256         /* This is relevant for all widgets */
 257         gnt_bindable_class_register_action(GNT_BINDABLE_CLASS(klass), "context-menu", context_menu,
 258                                 GNT_KEY_POPUP, NULL);
 259         gnt_bindable_register_binding(GNT_BINDABLE_CLASS(klass), "context-menu", GNT_KEY_F11, NULL);
 260
 261         gnt_style_read_actions(G_OBJECT_CLASS_TYPE(klass), GNT_BINDABLE_CLASS(klass));
 262         GNTDEBUG;
 263 }
 264
 265 /******************************************************************************
 266  * GntWidget API
 267  *****************************************************************************/
 268 GType
 269 gnt_widget_get_gtype(void)
 270 {
 271         static GType type = 0;
 272
 273         if(type == 0) {
 274                 static const GTypeInfo info = {
 275                         sizeof(GntWidgetClass),
 276                         NULL,                                   /* base_init            */
 277                         NULL,                                   /* base_finalize        */
 278                         (GClassInitFunc)gnt_widget_class_init,
 279                         NULL,
 280                         NULL,                                   /* class_data           */
 281                         sizeof(GntWidget),
 282                         0,                                              /* n_preallocs          */
 283                         gnt_widget_init,                                        /* instance_init        */
 284                         NULL                                    /* value_table          */
 285                 };
 286
 287                 type = g_type_register_static(GNT_TYPE_BINDABLE,
 288                                                                           "GntWidget",
 289                                                                           &info, G_TYPE_FLAG_ABSTRACT);
 290         }
 291
 292         return type;
 293 }
 294
 295 void gnt_widget_set_take_focus(GntWidget *widget, gboolean can)
 296 {
 297         if (can)
 298                 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_CAN_TAKE_FOCUS);
 299         else
 300                 GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_CAN_TAKE_FOCUS);
 301 }
 302
 303 /**
 304  * gnt_widget_destroy:
 305  * @obj: The #GntWidget instance.
 306  *
 307  * Emits the "destroy" signal notifying all reference holders that they
 308  * should release @obj.
 309  */
 310 void
 311 gnt_widget_destroy(GntWidget *obj)
 312 {
 313         g_return_if_fail(GNT_IS_WIDGET(obj));
 314
 315         if(!(GNT_WIDGET_FLAGS(obj) & GNT_WIDGET_DESTROYING)) {
 316                 GNT_WIDGET_SET_FLAGS(obj, GNT_WIDGET_DESTROYING);
 317                 gnt_widget_hide(obj);
 318                 delwin(obj->window);
 319                 g_object_run_dispose(G_OBJECT(obj));
 320         }
 321         GNTDEBUG;
 322 }
 323
 324 void
 325 gnt_widget_show(GntWidget *widget)
 326 {
 327         gnt_widget_draw(widget);
 328         gnt_screen_occupy(widget);
 329 }
 330
 331 void
 332 gnt_widget_draw(GntWidget *widget)
 333 {
 334         /* Draw the widget */
 335         if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_DRAWING))
 336                 return;
 337
 338         GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_DRAWING);
 339         if (!(GNT_WIDGET_FLAGS(widget) & GNT_WIDGET_MAPPED)) {
 340                 gnt_widget_map(widget);
 341         }
 342
 343         if (widget->window == NULL)
 344         {
 345 #if 0
 346                 int x, y, maxx, maxy, w, h;
 347                 int oldw, oldh;
 348                 gboolean shadow = TRUE;
 349
 350                 if (!gnt_widget_has_shadow(widget))
 351                         shadow = FALSE;
 352
 353                 x = widget->priv.x;
 354                 y = widget->priv.y;
 355                 w = oldw = widget->priv.width + shadow;
 356                 h = oldh = widget->priv.height + shadow;
 357
 358                 getmaxyx(stdscr, maxy, maxx);
 359                 maxy -= 1;              /* room for the taskbar */
 360
 361                 x = MAX(0, x);
 362                 y = MAX(0, y);
 363                 if (x + w >= maxx)
 364                         x = MAX(0, maxx - w);
 365                 if (y + h >= maxy)
 366                         y = MAX(0, maxy - h);
 367
 368                 w = MIN(w, maxx);
 369                 h = MIN(h, maxy);
 370
 371                 widget->priv.x = x;
 372                 widget->priv.y = y;
 373                 if (w != oldw || h != oldh) {
 374                         widget->priv.width = w - shadow;
 375                         widget->priv.height = h - shadow;
 376                         g_signal_emit(widget, signals[SIG_SIZE_CHANGED], 0, oldw, oldh);
 377                 }
 378 #else
 379                 widget->window = newpad(widget->priv.height + 20, widget->priv.width + 20);  /* XXX: */
 380 #endif
 381                 init_widget(widget);
 382         }
 383
 384         g_signal_emit(widget, signals[SIG_DRAW], 0);
 385         gnt_widget_queue_update(widget);
 386         GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_DRAWING);
 387 }
 388
 389 gboolean
 390 gnt_widget_key_pressed(GntWidget *widget, const char *keys)
 391 {
 392         gboolean ret;
 393         if (!GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_CAN_TAKE_FOCUS))
 394                 return FALSE;
 395
 396         if (!GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_DISABLE_ACTIONS) &&
 397                         gnt_bindable_perform_action_key(GNT_BINDABLE(widget), keys))
 398                 return TRUE;
 399
 400         keys = gnt_bindable_remap_keys(GNT_BINDABLE(widget), keys);
 401         g_signal_emit(widget, signals[SIG_KEY_PRESSED], 0, keys, &ret);
 402         return ret;
 403 }
 404
 405 gboolean
 406 gnt_widget_clicked(GntWidget *widget, GntMouseEvent event, int x, int y)
 407 {
 408         gboolean ret;
 409         g_signal_emit(widget, signals[SIG_CLICKED], 0, event, x, y, &ret);
 410         return ret;
 411 }
 412
 413 void
 414 gnt_widget_expose(GntWidget *widget, int x, int y, int width, int height)
 415 {
 416         g_signal_emit(widget, signals[SIG_EXPOSE], 0, x, y, width, height);
 417 }
 418
 419 void
 420 gnt_widget_hide(GntWidget *widget)
 421 {
 422         g_signal_emit(widget, signals[SIG_HIDE], 0);
 423         wbkgdset(widget->window, '\0' | gnt_color_pair(GNT_COLOR_NORMAL));
 424 #if 0
 425         /* XXX: I have no clue why, but this seemed to be necessary. */
 426         if (gnt_widget_has_shadow(widget))
 427                 mvwvline(widget->window, 1, widget->priv.width, ' ', widget->priv.height);
 428 #endif
 429         gnt_screen_release(widget);
 430         GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_INVISIBLE);
 431         GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_MAPPED);
 432 }
 433
 434 void
 435 gnt_widget_set_position(GntWidget *wid, int x, int y)
 436 {
 437         g_signal_emit(wid, signals[SIG_POSITION], 0, x, y);
 438         /* XXX: Need to install properties for these and g_object_notify */
 439         wid->priv.x = x;
 440         wid->priv.y = y;
 441 }
 442
 443 void
 444 gnt_widget_get_position(GntWidget *wid, int *x, int *y)
 445 {
 446         if (x)
 447                 *x = wid->priv.x;
 448         if (y)
 449                 *y = wid->priv.y;
 450 }
 451
 452 void
 453 gnt_widget_size_request(GntWidget *widget)
 454 {
 455         g_signal_emit(widget, signals[SIG_SIZE_REQUEST], 0);
 456 }
 457
 458 void
 459 gnt_widget_get_size(GntWidget *wid, int *width, int *height)
 460 {
 461         gboolean shadow = TRUE;
 462         if (!gnt_widget_has_shadow(wid))
 463                 shadow = FALSE;
 464
 465         if (width)
 466                 *width = wid->priv.width + shadow;
 467         if (height)
 468                 *height = wid->priv.height + shadow;
 469
 470 }
 471
 472 static void
 473 init_widget(GntWidget *widget)
 474 {
 475         gboolean shadow = TRUE;
 476
 477         if (!gnt_widget_has_shadow(widget))
 478                 shadow = FALSE;
 479
 480         wbkgd(widget->window, gnt_color_pair(GNT_COLOR_NORMAL));
 481         werase(widget->window);
 482
 483         if (!(GNT_WIDGET_FLAGS(widget) & GNT_WIDGET_NO_BORDER))
 484         {
 485                 /* - This is ugly. */
 486                 /* - What's your point? */
 487                 mvwvline(widget->window, 0, 0, ACS_VLINE | gnt_color_pair(GNT_COLOR_NORMAL), widget->priv.height);
 488                 mvwvline(widget->window, 0, widget->priv.width - 1,
 489                                 ACS_VLINE | gnt_color_pair(GNT_COLOR_NORMAL), widget->priv.height);
 490                 mvwhline(widget->window, widget->priv.height - 1, 0,
 491                                 ACS_HLINE | gnt_color_pair(GNT_COLOR_NORMAL), widget->priv.width);
 492                 mvwhline(widget->window, 0, 0, ACS_HLINE | gnt_color_pair(GNT_COLOR_NORMAL), widget->priv.width);
 493                 mvwaddch(widget->window, 0, 0, ACS_ULCORNER | gnt_color_pair(GNT_COLOR_NORMAL));
 494                 mvwaddch(widget->window, 0, widget->priv.width - 1,
 495                                 ACS_URCORNER | gnt_color_pair(GNT_COLOR_NORMAL));
 496                 mvwaddch(widget->window, widget->priv.height - 1, 0,
 497                                 ACS_LLCORNER | gnt_color_pair(GNT_COLOR_NORMAL));
 498                 mvwaddch(widget->window, widget->priv.height - 1, widget->priv.width - 1,
 499                                 ACS_LRCORNER | gnt_color_pair(GNT_COLOR_NORMAL));
 500         }
 501
 502         if (shadow)
 503         {
 504                 wbkgdset(widget->window, '\0' | gnt_color_pair(GNT_COLOR_SHADOW));
 505                 mvwvline(widget->window, 1, widget->priv.width, ' ', widget->priv.height);
 506                 mvwhline(widget->window, widget->priv.height, 1, ' ', widget->priv.width);
 507         }
 508 }
 509
 510 gboolean
 511 gnt_widget_set_size(GntWidget *widget, int width, int height)
 512 {
 513         gboolean ret = TRUE;
 514
 515         if (gnt_widget_has_shadow(widget))
 516         {
 517                 width--;
 518                 height--;
 519         }
 520         if (width <= 0)
 521                 width = widget->priv.width;
 522         if (height <= 0)
 523                 height = widget->priv.height;
 524
 525         if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_MAPPED))
 526         {
 527                 ret = gnt_widget_confirm_size(widget, width, height);
 528         }
 529
 530         if (ret)
 531         {
 532                 gboolean shadow = TRUE;
 533                 int oldw, oldh;
 534
 535                 if (!gnt_widget_has_shadow(widget))
 536                         shadow = FALSE;
 537
 538                 oldw = widget->priv.width;
 539                 oldh = widget->priv.height;
 540
 541                 widget->priv.width = width;
 542                 widget->priv.height = height;
 543                 if (width + shadow >= getmaxx(widget->window) || height + shadow >= getmaxy(widget->window)) {
 544                         delwin(widget->window);
 545                         widget->window = newpad(height + 20, width + 20);
 546                 }
 547
 548                 g_signal_emit(widget, signals[SIG_SIZE_CHANGED], 0, oldw, oldh);
 549
 550                 if (widget->window)
 551                 {
 552                         init_widget(widget);
 553                 }
 554                 if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_MAPPED))
 555                         init_widget(widget);
 556                 else
 557                         GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_MAPPED);
 558         }
 559
 560         return ret;
 561 }
 562
 563 gboolean
 564 gnt_widget_set_focus(GntWidget *widget, gboolean set)
 565 {
 566         if (!(GNT_WIDGET_FLAGS(widget) & GNT_WIDGET_CAN_TAKE_FOCUS))
 567                 return FALSE;
 568
 569         if (set && !GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_HAS_FOCUS))
 570         {
 571                 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_HAS_FOCUS);
 572                 g_signal_emit(widget, signals[SIG_GIVE_FOCUS], 0);
 573         }
 574         else if (!set && GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_HAS_FOCUS))
 575         {
 576                 GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_HAS_FOCUS);
 577                 g_signal_emit(widget, signals[SIG_LOST_FOCUS], 0);
 578         }
 579         else
 580                 return FALSE;
 581
 582         return TRUE;
 583 }
 584
 585 void gnt_widget_set_name(GntWidget *widget, const char *name)
 586 {
 587         g_free(widget->priv.name);
 588         widget->priv.name = g_strdup(name);
 589 }
 590
 591 const char *gnt_widget_get_name(GntWidget *widget)
 592 {
 593         return widget->priv.name;
 594 }
 595
 596 void gnt_widget_activate(GntWidget *widget)
 597 {
 598         g_signal_emit(widget, signals[SIG_ACTIVATE], 0);
 599 }
 600
 601 static gboolean
 602 update_queue_callback(gpointer data)
 603 {
 604         GntWidget *widget = GNT_WIDGET(data);
 605
 606         if (!g_object_get_data(G_OBJECT(widget), "gnt:queue_update"))
 607                 return FALSE;
 608         if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_MAPPED))
 609                 gnt_screen_update(widget);
 610         g_object_set_data(G_OBJECT(widget), "gnt:queue_update", NULL);
 611         return FALSE;
 612 }
 613
 614 void gnt_widget_queue_update(GntWidget *widget)
 615 {
 616         if (widget->window == NULL)
 617                 return;
 618         while (widget->parent)
 619                 widget = widget->parent;
 620
 621         if (!g_object_get_data(G_OBJECT(widget), "gnt:queue_update"))
 622         {
 623                 int id = g_timeout_add(0, update_queue_callback, widget);
 624                 g_object_set_data_full(G_OBJECT(widget), "gnt:queue_update", GINT_TO_POINTER(id),
 625                                 (GDestroyNotify)g_source_remove);
 626         }
 627 }
 628
 629 gboolean gnt_widget_confirm_size(GntWidget *widget, int width, int height)
 630 {
 631         gboolean ret = FALSE;
 632         g_signal_emit(widget, signals[SIG_CONFIRM_SIZE], 0, width, height, &ret);
 633         return ret;
 634 }
 635
 636 void gnt_widget_set_visible(GntWidget *widget, gboolean set)
 637 {
 638         if (set)
 639                 GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_INVISIBLE);
 640         else
 641                 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_INVISIBLE);
 642 }
 643
 644 gboolean gnt_widget_has_shadow(GntWidget *widget)
 645 {
 646         return (!GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_NO_SHADOW) &&
 647                         gnt_style_get_bool(GNT_STYLE_SHADOW, FALSE));
 648 }
 649