← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/xpad/oneiric

« back to all changes in this revision

Viewing changes to src/xpad-pad.c

  • Committer: Bazaar Package Importer
  • Author(s): Bart Martens
  • Date: 2007-12-10 22:52:37 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20071210225237-llvwje5iwbbi5adw
Tags: 2.13-1
* New upstream release.
* debian/patches/01_workspaces.diff: Removed.
* debian/menu: Updated.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xpad-pad.c
1
1
/*
2
2
 
3
 
Copyright (c) 2001-2005 Michael Terry
 
3
Copyright (c) 2001-2007 Michael Terry
4
4
 
5
5
This program is free software; you can redistribute it and/or modify
6
6
it under the terms of the GNU General Public License as published by
79
79
  LAST_PROP
80
80
};
81
81
 
82
 
static void load_info (XpadPad *pad);
 
82
static void load_info (XpadPad *pad, gboolean *show);
83
83
static void save_info (XpadPad *pad);
84
84
static void load_content (XpadPad *pad);
85
85
static void save_content (XpadPad *pad);
108
108
static void xpad_pad_popup (XpadPad *pad, GdkEventButton *event);
109
109
static void xpad_pad_spawn (XpadPad *pad);
110
110
static void xpad_pad_clear (XpadPad *pad);
111
 
static void xpad_pad_close (XpadPad *pad);
112
111
static void xpad_pad_delete (XpadPad *pad);
113
112
static void xpad_pad_open_properties (XpadPad *pad);
114
113
static void xpad_pad_open_preferences (XpadPad *pad);
115
114
static void xpad_pad_quit (XpadPad *pad);
 
115
static void xpad_pad_close_all (XpadPad *pad);
116
116
static void xpad_pad_sync_title (XpadPad *pad);
117
117
static void xpad_pad_set_group (XpadPad *pad, XpadPadGroup *group);
118
118
static gboolean xpad_pad_leave_notify_event (GtkWidget *pad, GdkEventCrossing *event);
130
130
}
131
131
 
132
132
GtkWidget *
133
 
xpad_pad_new_with_info (XpadPadGroup *group, const gchar *info_filename)
 
133
xpad_pad_new_with_info (XpadPadGroup *group, const gchar *info_filename, gboolean *show)
134
134
{
135
135
        GtkWidget *pad = GTK_WIDGET (g_object_new (XPAD_TYPE_PAD, "group", group, NULL));
136
136
        
137
137
        XPAD_PAD (pad)->priv->infoname = g_strdup (info_filename);
138
 
        load_info (XPAD_PAD (pad));
 
138
        load_info (XPAD_PAD (pad), show);
139
139
        load_content (XPAD_PAD (pad));
 
140
        gtk_window_set_role (GTK_WINDOW (pad), XPAD_PAD (pad)->priv->infoname);
140
141
        
141
142
        return pad;
142
143
}
168
169
                g_free (content);
169
170
                
170
171
                g_signal_handlers_unblock_by_func (buffer, xpad_pad_text_changed, pad);
171
 
                xpad_pad_text_changed(pad, buffer);
 
172
                xpad_pad_text_changed(XPAD_PAD(pad), buffer);
172
173
        }
173
174
        
174
175
        return pad;
221
222
        pad->priv->height = xpad_settings_get_height (xpad_settings ());
222
223
        pad->priv->infoname = NULL;
223
224
        pad->priv->contentname = NULL;
224
 
        pad->priv->sticky = FALSE;
 
225
        pad->priv->sticky = xpad_settings_get_sticky (xpad_settings ());
225
226
        pad->priv->textview = NULL;
226
227
        pad->priv->scrollbar = NULL;
227
228
        pad->priv->toolbar = NULL;
254
255
        g_object_unref (G_OBJECT (accel_group));
255
256
        pad->priv->menu = menu_get_popup_no_highlight (pad, accel_group);
256
257
        pad->priv->highlight_menu = menu_get_popup_highlight (pad, accel_group);
 
258
        gtk_accel_group_connect (accel_group, GDK_Q, GDK_CONTROL_MASK, 0,
 
259
                                 g_cclosure_new_swap (G_CALLBACK (xpad_pad_quit), pad, NULL));
 
260
 
257
261
        
258
262
        vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
259
263
                "homogeneous", FALSE,
272
276
                "skip-taskbar-hint", !xpad_settings_get_has_decorations (xpad_settings ()),
273
277
                "type", GTK_WINDOW_TOPLEVEL,
274
278
                "type-hint", GDK_WINDOW_TYPE_HINT_NORMAL,
275
 
                "window-position", GTK_WIN_POS_NONE,
 
279
                "window-position", GTK_WIN_POS_MOUSE,
276
280
                "child", vbox,
277
281
                NULL);
278
282
        
306
310
        g_signal_connect_swapped (pad->priv->toolbar, "activate-delete", G_CALLBACK (xpad_pad_delete), pad);
307
311
        g_signal_connect_swapped (pad->priv->toolbar, "activate-properties", G_CALLBACK (xpad_pad_open_properties), pad);
308
312
        g_signal_connect_swapped (pad->priv->toolbar, "activate-preferences", G_CALLBACK (xpad_pad_open_preferences), pad);
309
 
        g_signal_connect_swapped (pad->priv->toolbar, "activate-quit", G_CALLBACK (xpad_pad_quit), pad);
 
313
        g_signal_connect_swapped (pad->priv->toolbar, "activate-quit", G_CALLBACK (xpad_pad_close_all), pad);
310
314
        
311
315
        g_signal_connect (pad->priv->toolbar, "popup", G_CALLBACK (xpad_pad_toolbar_popup), pad);
312
316
        g_signal_connect (pad->priv->toolbar, "popdown", G_CALLBACK (xpad_pad_toolbar_popdown), pad);
314
318
        g_signal_connect (pad->priv->menu, "deactivate", G_CALLBACK (xpad_pad_popup_deactivate), pad);
315
319
        g_signal_connect (pad->priv->highlight_menu, "deactivate", G_CALLBACK (xpad_pad_popup_deactivate), pad);
316
320
        
317
 
        if (xpad_settings_get_sticky (xpad_settings ()))
 
321
        if (pad->priv->sticky)
318
322
                gtk_window_stick (GTK_WINDOW (pad));
319
323
        else
320
324
                gtk_window_unstick (GTK_WINDOW (pad));
344
348
                "gravity", GDK_GRAVITY_STATIC,
345
349
                "skip-pager-hint", TRUE,
346
350
                "skip-taskbar-hint", TRUE,
347
 
                NULL);
 
351
                NULL);*/
348
352
        
349
 
        if (xpad_settings_get_sticky (xpad_settings ()))
 
353
        if (pad->priv->sticky)
350
354
                gtk_window_stick (GTK_WINDOW (pad));
351
355
        else
352
356
                gtk_window_unstick (GTK_WINDOW (pad));
353
357
        
354
 
        xpad_pad_sync_title (pad);*/
 
358
/*      xpad_pad_sync_title (pad);*/
355
359
}
356
360
 
357
361
static void
414
418
static void
415
419
xpad_pad_notify_has_decorations (XpadPad *pad)
416
420
{
417
 
        gboolean shown = GTK_WIDGET_VISIBLE (GTK_WIDGET (pad));
418
421
        gboolean decorations = xpad_settings_get_has_decorations (xpad_settings ());
419
422
        
420
423
        /**
456
459
        if (!GTK_WIDGET_VISIBLE (pad->priv->toolbar))
457
460
        {
458
461
                GtkRequisition req;
459
 
                GdkRectangle rec;
460
 
                gint textx, texty, x, y;
461
 
                GtkTextIter iter;
462
462
                
463
463
                if (GTK_WIDGET (pad)->window)
464
464
                        gdk_window_freeze_updates (GTK_WIDGET (pad)->window);
491
491
{
492
492
        if (GTK_WIDGET_VISIBLE (pad->priv->toolbar))
493
493
        {
494
 
                GdkRectangle rec;
495
 
                gint textx, texty, x, y;
496
 
                GtkTextIter iter;
497
 
                
498
494
                if (GTK_WIDGET (pad)->window)
499
495
                        gdk_window_freeze_updates (GTK_WIDGET (pad)->window);
500
496
                gtk_widget_hide (pad->priv->toolbar);
596
592
        gtk_text_buffer_set_text (buffer, "", -1);
597
593
}
598
594
 
599
 
static void
 
595
void
600
596
xpad_pad_close (XpadPad *pad)
601
597
{
602
598
        gtk_widget_hide (GTK_WIDGET (pad));
603
599
        
 
600
        /* If no tray and this is the last pad, we don't want to record this
 
601
           pad as closed, we want to start with just this pad next open.  So
 
602
           quit before we record. */
 
603
        if (!xpad_tray_is_open () &&
 
604
            xpad_pad_group_num_visible_pads (pad->priv->group) == 0)
 
605
        {
 
606
                xpad_pad_quit (pad);
 
607
                return;
 
608
        }
 
609
        
604
610
        if (pad->priv->properties)
605
611
                gtk_widget_destroy (pad->priv->properties);
606
612
        
834
840
static gboolean
835
841
xpad_pad_configure_event (XpadPad *pad, GdkEventConfigure *event)
836
842
{
 
843
        if (!GTK_WIDGET_VISIBLE (pad))
 
844
                return FALSE;
 
845
        
837
846
        if (pad->priv->width != event->width || pad->priv->height != event->height)
838
847
                pad->priv->toolbar_pad_resized = TRUE;
839
848
        
860
869
static gboolean
861
870
xpad_pad_window_state_event (XpadPad *pad, GdkEventWindowState *event)
862
871
{
863
 
        pad->priv->sticky = (event->new_window_state & GDK_WINDOW_STATE_STICKY) ? TRUE : FALSE;
864
 
        
865
 
        if (event->changed_mask & GDK_WINDOW_STATE_STICKY)
866
 
                save_info (pad);
 
872
        if (event->changed_mask & GDK_WINDOW_STATE_STICKY) {
 
873
                if (GTK_WIDGET_VISIBLE (pad))
 
874
                {
 
875
                        pad->priv->sticky = (event->new_window_state & GDK_WINDOW_STATE_STICKY) ? TRUE : FALSE;
 
876
                        save_info (pad);
 
877
                }
 
878
        }
867
879
        
868
880
        return FALSE;
869
881
}
1072
1084
}
1073
1085
 
1074
1086
static void
1075
 
load_info (XpadPad *pad)
 
1087
load_info (XpadPad *pad, gboolean *show)
1076
1088
{
1077
1089
        gboolean locked = FALSE, follow_font = TRUE, follow_color = TRUE;
1078
1090
        gboolean hidden = FALSE;
1157
1169
        }
1158
1170
        g_free (oldcontentprefix);
1159
1171
        
1160
 
        if (hidden)
1161
 
                gtk_widget_hide (GTK_WIDGET (pad));
 
1172
        if (show)
 
1173
                *show = !hidden;
1162
1174
}
1163
1175
 
1164
1176
static void
1174
1186
                pad->priv->infoname = fio_unique_name ("info-");
1175
1187
                if (!pad->priv->infoname)
1176
1188
                        return;
 
1189
                gtk_window_set_role (GTK_WINDOW (pad), pad->priv->infoname);
1177
1190
        }
1178
1191
        /* create content file if it doesn't exist yet */
1179
1192
        if (!pad->priv->contentname)
1198
1211
                "b|follow_font", xpad_text_view_get_follow_font_style (XPAD_TEXT_VIEW (pad->priv->textview)),
1199
1212
                "b|follow_color", xpad_text_view_get_follow_color_style (XPAD_TEXT_VIEW (pad->priv->textview)),
1200
1213
                "b|sticky", pad->priv->sticky,
1201
 
                "b|hidden", GTK_WIDGET_VISIBLE (pad),
 
1214
                "b|hidden", !GTK_WIDGET_VISIBLE (pad),
1202
1215
                "h|back_red", style->base[GTK_STATE_NORMAL].red,
1203
1216
                "h|back_green", style->base[GTK_STATE_NORMAL].green,
1204
1217
                "h|back_blue", style->base[GTK_STATE_NORMAL].blue,
1218
1231
        const gchar *artists[] = {"Michael Terry <mike@mterry.name>", NULL};
1219
1232
        const gchar *authors[] = {"Michael Terry <mike@mterry.name>", "Jeroen Vermeulen <jtv@xs4all.nl>", NULL};
1220
1233
        const gchar *comments = _("Sticky notes");
1221
 
        const gchar *copyright = "© 2001-2006 Michael Terry";
 
1234
        const gchar *copyright = "© 2001-2007 Michael Terry";
1222
1235
        /* we use g_strdup_printf because C89 has size limits on static strings */
1223
1236
        gchar *license = g_strdup_printf ("%s\n%s\n%s",
1224
1237
"This program is free software; you can redistribute it and/or\n"
1302
1315
}
1303
1316
 
1304
1317
static void
 
1318
xpad_pad_close_all (XpadPad *pad)
 
1319
{
 
1320
        if (!pad->priv->group)
 
1321
                return;
 
1322
        
 
1323
        /**
 
1324
         * The logic is different here depending on whether the tray is open.
 
1325
         * If it is open, we just close each pad individually.  If it isn't
 
1326
         * open, we do a quit.  This way, when xpad is run again, only the
 
1327
         * pads open during the last 'close all' will open again.
 
1328
         */
 
1329
        if (xpad_tray_is_open ())
 
1330
                xpad_pad_group_close_all (pad->priv->group);
 
1331
        else
 
1332
                xpad_pad_quit (pad);
 
1333
}
 
1334
 
 
1335
static void
1305
1336
menu_show (XpadPad *pad)
1306
1337
{
1307
1338
        gtk_window_present (GTK_WINDOW (pad));
1467
1498
        MENU_ADD_STOCK (GTK_STOCK_NEW, xpad_pad_spawn);
1468
1499
        MENU_ADD_SEP ();
1469
1500
        MENU_ADD_CHECK (_("Show on _All Workspaces"), pad->priv->sticky, menu_sticky);
 
1501
        g_object_set_data (G_OBJECT (uppermenu), "sticky", item);
1470
1502
        MENU_ADD_STOCK (GTK_STOCK_PROPERTIES, xpad_pad_open_properties);
1471
1503
        MENU_ADD_SEP ();
1472
1504
        MENU_ADD_STOCK (GTK_STOCK_CLOSE, xpad_pad_close);
1509
1541
        g_object_set_data (G_OBJECT (uppermenu), "notes-menu", menu);
1510
1542
        
1511
1543
        MENU_ADD (_("_Show All"), NULL, 0, 0, menu_show_all);
1512
 
        MENU_ADD (_("_Close All"), GTK_STOCK_QUIT, GDK_q, GDK_CONTROL_MASK, xpad_pad_quit);
 
1544
        MENU_ADD (_("_Close All"), NULL, 0, 0, xpad_pad_close_all);
1513
1545
        
1514
1546
        /* The rest of the notes menu will get set up in the prep function below */
1515
1547
        
1538
1570
        if (item)
1539
1571
                gtk_widget_set_sensitive (item, gtk_clipboard_wait_is_text_available (clipboard));
1540
1572
        
 
1573
        item = g_object_get_data (G_OBJECT (uppermenu), "sticky");
 
1574
        if (item) {
 
1575
                g_signal_handlers_block_by_func (item, menu_sticky, current_pad);
 
1576
                gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), current_pad->priv->sticky);
 
1577
                g_signal_handlers_unblock_by_func (item, menu_sticky, current_pad);
 
1578
        }
 
1579
        
1541
1580
        menu = g_object_get_data (G_OBJECT (uppermenu), "notes-menu");
1542
1581
        if (menu)
1543
1582
        {