diff options
| author | The Squash <[email protected]> | 2022-05-06 01:11:58 -0400 |
|---|---|---|
| committer | Victor Kareh <[email protected]> | 2022-06-01 10:14:33 -0400 |
| commit | 38e00280e9d17282717595a05411736a308804c0 (patch) | |
| tree | 533df0f579a46ce990f9d5ee93dda1f70134b7ce /mate-panel/panel-widget.c | |
| parent | 02618b724a15443f6e5b4ce05612204d41269fa4 (diff) | |
| download | mate-panel-38e00280e9d17282717595a05411736a308804c0.tar.bz2 mate-panel-38e00280e9d17282717595a05411736a308804c0.tar.xz | |
Add "center-stick" capability applets on the panel
Conventionally, the applets on a MATE Panel are positioned relative to the
left edge of the panel (if the panel is horizontal) or the top edge (if the
panel is vertical). There has also been some (buggy) support for positioning
of applets relative to the right (or bottom) edge of the panel, so that
applets on the right side of the panel will stay on the right side even if
the user changes screen resolutions or if the panel changes size for some
other reason.
However, many users want to also place applets at or near the center of their
panel(s). There is no such conventional support for positioning applets
relative to the center of the panel, so users have positioned applets near
the center of the panel -- but the position recorded is relative to the left
side of the panel. As such, the applets will almost certainly shift over
to the left or right slightly if the panel is ever resized, and the user will
have to reposition all those centered applets yet again. This is especially
frustrating if the user switches monitors on a regular basis!
This patch radically revamps the MATE Panel's positioning framework, and
deprecates the original "right-stick" feature. To replace the right-stick
feature, this patch instead associates an "edge relativity" setting with
each and every panel applet: An applet can be relative to the start (left/
top), end (right/bottom), or center of the panel. This setting can be
changed using DConf/GSettings, using a custom panel layout file, or even
by simply dragging the applet to the appropriate place on the panel.
(Conventionally, applets are not even right-stuck automatically even when the
user drags the applet over to the far right of the panel!) As a bonus, when
the user drags an applet across the center of the panel, the applet will
temporarily "stick" to the very center of the panel, to allow the user to
very precisely align any applet they wish.
Diffstat (limited to 'mate-panel/panel-widget.c')
| -rw-r--r-- | mate-panel/panel-widget.c | 339 |
1 files changed, 268 insertions, 71 deletions
diff --git a/mate-panel/panel-widget.c b/mate-panel/panel-widget.c index a8c01854..822b8100 100644 --- a/mate-panel/panel-widget.c +++ b/mate-panel/panel-widget.c @@ -30,8 +30,11 @@ #include "panel-globals.h" #include "panel-profile.h" #include "panel-lockdown.h" +#include "panel-schemas.h" -#define MOVE_INCREMENT 1 +#define MOVE_INCREMENT 1 +/* The following was originally from panel-toplevel.c */ +#define SNAP_TOLERANCE_FACTOR 6 typedef enum { PANEL_SWITCH_MOVE = 0, @@ -623,36 +626,92 @@ get_applet_list_pos (PanelWidget *panel, return NULL; } -/*tells us if an applet is "stuck" on the right side*/ -int -panel_widget_is_applet_stuck (PanelWidget *panel_widget, - GtkWidget *widget) +/* + * This function determines whether the given panel applet should be positioned + * relative to the center or end of the panel; that is, whether the applet + * is part of a contiguous group of other applets, one of which touches the + * center or end of the panel. + */ +PanelObjectEdgeRelativity +panel_widget_determine_applet_edge_relativity (PanelWidget *panel_widget, + GtkWidget *widget) { - AppletData *applet; + AppletData *applet_in_question; + gboolean applet_is_centered = FALSE; - g_return_val_if_fail (PANEL_IS_WIDGET (panel_widget), FALSE); - g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); + g_return_val_if_fail (PANEL_IS_WIDGET (panel_widget), PANEL_EDGE_START); + g_return_val_if_fail (GTK_IS_WIDGET (widget), PANEL_EDGE_START); - applet = g_object_get_data (G_OBJECT (widget), MATE_PANEL_APPLET_DATA); - if (applet) { - GList *applet_list, *l; - int end_pos = -1; + applet_in_question = g_object_get_data (G_OBJECT (widget), MATE_PANEL_APPLET_DATA); + if (applet_in_question) { + GList *applet_list, *l; + AppletData *applet; + int start_pos, end_pos; - applet_list = g_list_find (panel_widget->applet_list, applet); + applet_list = g_list_find (panel_widget->applet_list, applet_in_question); + start_pos = applet_in_question->pos + applet_in_question->cells; + end_pos = applet_in_question->pos; - for (l = applet_list; l; l = l->next) { + /* + * Start by moving towards the start of the panel, checking + * whether any applets lie on the panel's center. + */ + for (l = applet_list; l; l = l->prev) + { applet = l->data; - if (end_pos != -1 && applet->pos != end_pos) + if (applet->pos + applet->cells < end_pos) break; - end_pos = applet->pos + applet->cells; - if (end_pos >= panel_widget->size) - return TRUE; + if (applet->pos <= panel_widget->size/2 && + applet->pos + applet->cells > panel_widget->size/2) + applet_is_centered = TRUE; + + end_pos -= applet->cells; + if (end_pos <= 0) + /* + * If the applet in question is part of a line + * of contiguous applets, the first of which + * touches the start of the panel, then don't + * center this applet under any circumstances. + */ + return PANEL_EDGE_START; + } + + if (applet_is_centered) + return PANEL_EDGE_CENTER; + + /* + * Now move towards the panel's end, looking for applets that + * cross the center of the panel. + */ + for (l = applet_list; l; l = l->next) + { + applet = l->data; + + if (applet->pos > start_pos) + break; + + if (applet->pos <= panel_widget->size/2 && + applet->pos + applet->cells > panel_widget->size/2) + applet_is_centered = TRUE; + + start_pos += applet->cells; + if (start_pos >= panel_widget->size) + /* + * If the applet in question is part of a line + * of contiguous applets, the last of which + * touches the end of the panel, then the + * applet is actually end-relative. + */ + return PANEL_EDGE_END; } } - return FALSE; + if (applet_is_centered) + return PANEL_EDGE_CENTER; + else + return PANEL_EDGE_START; } static int @@ -676,6 +735,24 @@ get_size_from_hints (AppletData *ad, int cells) return MAX (cells, ad->min_cells); } +/* + * A utility function to adjust an applet's position by its allocated size, + * if the applet is end-relative or centered. + */ +static void +adjust_applet_position (PanelWidget *panel, + AppletData *ad) +{ + PanelObjectEdgeRelativity edge_relativity; + + edge_relativity = panel_widget_determine_applet_edge_relativity (panel, ad->applet); + + if (edge_relativity == PANEL_EDGE_CENTER) + ad->pos += ad->cells/2; + else if (edge_relativity == PANEL_EDGE_END) + ad->pos += ad->cells; +} + static void panel_widget_jump_applet_right (PanelWidget *panel, GList *list, @@ -705,6 +782,7 @@ panel_widget_jump_applet_right (PanelWidget *panel, jump_right: ad->pos = ad->constrained = pos; + adjust_applet_position (panel, ad); panel->applet_list = g_list_remove_link (panel->applet_list, list); panel->applet_list = panel_g_list_insert_before (panel->applet_list, next, list); gtk_widget_queue_resize (GTK_WIDGET (panel)); @@ -729,6 +807,7 @@ panel_widget_switch_applet_right (PanelWidget *panel, if (!nad || nad->constrained >= ad->constrained + ad->min_cells + MOVE_INCREMENT) { ad->pos = ad->constrained += MOVE_INCREMENT; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); return; @@ -744,6 +823,8 @@ panel_widget_switch_applet_right (PanelWidget *panel, nad->constrained = nad->pos = ad->constrained; ad->constrained = ad->pos = ad->constrained + nad->min_cells; + adjust_applet_position (panel, nad); + adjust_applet_position (panel, ad); panel->applet_list = panel_g_list_swap_next (panel->applet_list, list); gtk_widget_queue_resize (GTK_WIDGET (panel)); @@ -781,6 +862,7 @@ panel_widget_jump_applet_left (PanelWidget *panel, jump_left: ad->pos = ad->constrained = pos; + adjust_applet_position (panel, ad); panel->applet_list = g_list_remove_link (panel->applet_list, list); panel->applet_list = panel_g_list_insert_after (panel->applet_list, prev, list); gtk_widget_queue_resize (GTK_WIDGET (panel)); @@ -803,6 +885,7 @@ panel_widget_switch_applet_left (PanelWidget *panel, if (!pad || pad->constrained + pad->min_cells <= ad->constrained - MOVE_INCREMENT) { ad->pos = ad->constrained -= MOVE_INCREMENT; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); return; @@ -818,6 +901,8 @@ panel_widget_switch_applet_left (PanelWidget *panel, ad->constrained = ad->pos = pad->constrained; pad->constrained = pad->pos = ad->constrained + ad->min_cells; + adjust_applet_position (panel, ad); + adjust_applet_position (panel, pad); panel->applet_list = panel_g_list_swap_prev (panel->applet_list, list); gtk_widget_queue_resize (GTK_WIDGET (panel)); @@ -1060,6 +1145,7 @@ panel_widget_push_applet_right (PanelWidget *panel, if (!nad || nad->constrained >= ad->constrained + ad->min_cells + push) { ad->pos = ad->constrained += push; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); return TRUE; @@ -1071,6 +1157,7 @@ panel_widget_push_applet_right (PanelWidget *panel, return FALSE; ad->pos = ad->constrained += push;; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); @@ -1099,6 +1186,7 @@ panel_widget_push_applet_left (PanelWidget *panel, if (!pad || pad->constrained + pad->min_cells <= ad->constrained - push) { ad->pos = ad->constrained -= push; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); return TRUE; @@ -1110,6 +1198,7 @@ panel_widget_push_applet_left (PanelWidget *panel, return FALSE; ad->pos = ad->constrained -= push; + adjust_applet_position (panel, ad); gtk_widget_queue_resize (GTK_WIDGET (panel)); emit_applet_moved (panel, ad); @@ -1152,46 +1241,6 @@ panel_widget_push_move (PanelWidget *panel, } } -/*this is a special function and may fail if called improperly, it works -only under special circumstance when we know there is nothing from -old_size to panel->size*/ -static void -panel_widget_right_stick(PanelWidget *panel,int old_size) -{ - int i,pos; - GList *list,*prev; - AppletData *ad; - - g_return_if_fail(PANEL_IS_WIDGET(panel)); - g_return_if_fail(old_size>=0); - - if(old_size>=panel->size || - panel->packed) - return; - - list = get_applet_list_pos(panel,old_size-1); - - if(!list) - return; - - pos = panel->size-1; - - ad = list->data; - do { - i = ad->pos; - ad->pos = ad->constrained = pos--; - ad->cells = 1; - prev = list; - list = g_list_previous(list); - if(!list) - break; - ad = list->data; - } while(ad->pos + ad->cells == i); - - for (list = prev; list; list = list->next) - emit_applet_moved (panel, list->data); -} - static void panel_widget_get_preferred_size(GtkWidget *widget, GtkRequisition *minimum_size, @@ -1361,7 +1410,6 @@ panel_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation) PanelWidget *panel; GList *list; int i; - int old_size; gboolean ltr; g_return_if_fail(PANEL_IS_WIDGET(widget)); @@ -1369,7 +1417,6 @@ panel_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation) panel = PANEL_WIDGET(widget); - old_size = panel->size; ltr = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR; gtk_widget_set_allocation (widget, allocation); @@ -1384,8 +1431,6 @@ panel_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation) panel->size = allocation->width; else panel->size = allocation->height; - if(old_size<panel->size) - panel_widget_right_stick(panel,old_size); if (panel->packed) { /* we're assuming the order is the same as the one that was @@ -1442,13 +1487,30 @@ panel_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation) } else { /*not packed*/ - /* First make sure there's enough room on the left */ + /* + * First, recalculate the ideal position for each applet on the + * panel, since the panel changed size, and the position of + * end-relative and center-relative applets depends on the + * exact size of the panel. + * + * However, if some applet uses a large amount of space on the + * panel, it's possible that the ideal applet positions cannot + * be attained, unless of course panel applets were to overlap. + * Since we don't want any panel applets to overlap, shift any + * following applets further over to the right as much as + * necessary. + */ + i = 0; - for (list = panel->applet_list; - list != NULL; - list = g_list_next (list)) { + for (list = panel->applet_list; list; list = list->next) + { AppletData *ad = list->data; GtkRequisition chreq; + const char *id; + AppletInfo *info; + int position = ad->pos; + PanelObjectEdgeRelativity edge_relativity = PANEL_EDGE_START; + gboolean right_stuck = FALSE; gtk_widget_get_preferred_size (ad->applet, &chreq, NULL); @@ -1464,10 +1526,96 @@ panel_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation) ad->min_cells = ad->size_hints [ad->size_hints_len - 1]; } - ad->constrained = ad->pos; + id = mate_panel_applet_get_id_by_widget (ad->applet); + if (id) + { + info = mate_panel_applet_get_by_id (id); + position = g_settings_get_int (info->settings, + PANEL_OBJECT_POSITION_KEY); + edge_relativity = g_settings_get_enum (info->settings, + PANEL_OBJECT_RELATIVE_TO_EDGE_KEY); + right_stuck = g_settings_get_boolean (info->settings, + PANEL_OBJECT_PANEL_RIGHT_STICK_KEY); + } + + /* + * Do not attempt to re-position the applet if it is + * currently being dragged or otherwise moved by the + * user; otherwise, we'll immediately undo the user's + * last move and thus thwart all the user's attempts + * to move the applet! + */ + if (ad != panel->currently_dragged_applet) + { + if (edge_relativity == PANEL_EDGE_CENTER) + { + ad->pos = panel->size/2 + position; + ad->constrained = ad->pos - ad->cells/2; + } + else if (edge_relativity == PANEL_EDGE_END) + { + ad->pos = panel->size - position; + /* + * If the `panel-right-stick` property + * is set on the applet, position the + * left side of the applet relative to + * the right side of the panel, not + * the right side of the applet relative + * to the right side of the panel like + * we'd normally do. This is a hack for + * better backward compatibility. See + * the huge comment in the function + * `panel_profile_load_object ()` in + * the file `panel-profile.c` for much, + * much more discussion of this hack. + */ + if (right_stuck) + ad->constrained = ad->pos; + else + ad->constrained = ad->pos - ad->cells; + } + else + { + ad->pos = position; + ad->constrained = ad->pos; + } + } + + /* + * Now if the previous applet uses too much room on the + * panel to ideally fit this applet, move this applet + * further over to the right to compensate. + * + * Centered applets are a somewhat different story. + * If the current applet is centered, and the previous + * applet is also centered and has a negative relative + * position (so the previous applet is "left" of + * center), move the *previous* applet over to the + * *left* to compensate. This way, applets at dead + * center will remain at or near dead center. + */ if (ad->constrained < i) - ad->constrained = i; + { + AppletData *pad = NULL; + PanelObjectEdgeRelativity previous_edge_relativity; + + previous_edge_relativity = PANEL_EDGE_START; + + if (list->prev) + { + pad = list->prev->data; + previous_edge_relativity = panel_widget_determine_applet_edge_relativity (panel, pad->applet); + } + + if (edge_relativity == PANEL_EDGE_CENTER && + pad && + previous_edge_relativity == PANEL_EDGE_CENTER && + pad->constrained + pad->cells/2 < panel->size/2) + pad->constrained = ad->constrained - pad->cells; + else + ad->constrained = i; + } i = ad->constrained + ad->cells; } @@ -1754,12 +1902,20 @@ panel_widget_applet_drag_start_no_grab (PanelWidget *panel, static void panel_widget_applet_drag_end_no_grab (PanelWidget *panel) { + AppletInfo *info; + g_return_if_fail (panel != NULL); g_return_if_fail (PANEL_IS_WIDGET (panel)); #ifdef PANEL_WIDGET_DEBUG g_message("Ending drag\n"); #endif + + /* Immediately save the new position of the applet. */ + info = g_object_get_data (G_OBJECT (panel->currently_dragged_applet->applet), "applet_info"); + if (info) + mate_panel_applet_save_position (info, info->id, TRUE); + panel->currently_dragged_applet = NULL; mate_panel_applet_in_drag = FALSE; @@ -2000,6 +2156,7 @@ panel_widget_nice_move (PanelWidget *panel, return; ad->pos = ad->constrained = pos; + adjust_applet_position (panel, ad); panel->applet_list = panel_g_list_resort_item (panel->applet_list, ad, @@ -2025,6 +2182,10 @@ panel_widget_applet_move_to_cursor (PanelWidget *panel) GSList *forb; GdkModifierType mods; AppletData *ad; + GtkSettings *settings; + int drag_threshold; + int absolute_moveby; + int centered_applet_position; g_return_if_fail(PANEL_IS_WIDGET(panel)); @@ -2093,16 +2254,51 @@ panel_widget_applet_move_to_cursor (PanelWidget *panel) movement = PANEL_FREE_MOVE; } + moveby = panel_widget_get_moveby (panel, pos, ad->drag_off); + + /* + * If the applet is currently positioned at the dead center of the + * panel, or if the user moved the mouse across the center of the + * panel (but not farther from the center than the drag-and-drop + * threshold times a specific constant), make the applet "stick" to + * the center of the panel until the user tries to drag the applet far + * away from the center again. This way, the user can move an applet + * to the center of the panel without needing superhuman muscle + * control to get the applet perfectly centered. + */ + settings = gtk_widget_get_settings (GTK_WIDGET (panel)); + g_object_get (G_OBJECT (settings), + "gtk-dnd-drag-threshold", &drag_threshold, + NULL); + + centered_applet_position = panel->size/2 - ad->cells/2; + + if ((moveby < 0 && pos > centered_applet_position && + pos+moveby <= centered_applet_position && + pos+moveby >= centered_applet_position - drag_threshold*SNAP_TOLERANCE_FACTOR) || + (moveby > 0 && pos < centered_applet_position && + pos+moveby >= centered_applet_position && + pos+moveby <= centered_applet_position + drag_threshold*SNAP_TOLERANCE_FACTOR)) + moveby = centered_applet_position - pos; + else if (pos == centered_applet_position) + { + if (moveby < 0) + absolute_moveby = -moveby; + else + absolute_moveby = moveby; + + if (absolute_moveby < drag_threshold*SNAP_TOLERANCE_FACTOR) + return; + } + switch (movement) { case PANEL_SWITCH_MOVE: - moveby = panel_widget_get_moveby (panel, pos, ad->drag_off); panel_widget_switch_move (panel, ad, moveby); break; case PANEL_FREE_MOVE: panel_widget_nice_move (panel, ad, panel_widget_get_cursorloc (panel)); break; case PANEL_PUSH_MOVE: - moveby = panel_widget_get_moveby (panel, pos, ad->drag_off); panel_widget_push_move (panel, ad, moveby); break; } @@ -2573,6 +2769,7 @@ panel_widget_reparent (PanelWidget *old_panel, if (info && info->type == PANEL_OBJECT_APPLET) mate_panel_applet_frame_set_panel (MATE_PANEL_APPLET_FRAME (ad->applet), new_panel); + adjust_applet_position (new_panel, ad); if (gtk_widget_get_can_focus (GTK_WIDGET (new_panel))) gtk_widget_set_can_focus (GTK_WIDGET (new_panel), FALSE); |