aviumcaravan/siemens-rtl
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
siemens-rtl/manage.c
Riley Ambers 03b4bdc215 Initial commit
2023-07-11 14:40:13 +02:00

5344 lines
146 KiB
C
Raw Permalink Blame History

#ifndef lint
static char sccs_id[] = "@(#)manage.c 5.7 9/1/88";
#endif
/*
* Copyright 1988 by Siemens Research and Technology Laboratories, Princeton, NJ
*
* All Rights Reserved
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation, and that the name of Siemens Research and Technology
* Laboratories not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior permission.
*
*
* SIEMENS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
* SIEMENS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
* ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
#include <stdlib.h>
#include "copyright.h"
#include "basetype.h"
#include "userglobD.h"
#include "twin.h"
#ifndef TILWIN_DEFINE
#include "twinD.h"
#endif
#ifndef USERWIN_DEFINE
#include "uwinD.h"
#endif
#include "uwinL.h"
#include "uwinvalP.h"
#include "client.h"
#include "closed.h"
#include "draw.h"
#include "drawicon.h"
#include "drawwin.h"
#include "layout.h"
#include "profile.h"
#include "region.h"
/* ------------------------------------------------------------ */
#define SWAP_BOOL( val1, val2 ) \
{ \
bool temp; \
temp = val1; \
val1 = val2; \
val2 = temp; \
}
/* ------------------------------------------------------------ */
#define SWAP_INT( val1, val2 ) \
{ \
int temp; \
temp = val1; \
val1 = val2; \
val2 = temp; \
}
/* ------------------------------------------------------------ */
#define SWAP_POS( val1, val2 ) \
{ \
TWPoint temp; \
temp = val1; \
val1 = val2; \
val2 = temp; \
}
/* ------------------------------------------------------------ */
#define SWAP_SIZE( val1, val2 ) \
{ \
Size temp; \
temp = val1; \
val1 = val2; \
val2 = temp; \
}
/* ------------------------------------------------------------ */
#define SWAP_RECT( val1, val2 ) \
{ \
TWRectangle temp; \
temp = val1; \
val1 = val2; \
val2 = temp; \
}
/* ------------------------------------------------------------ */
#define SWAP_UWINP( uwinp1, uwinp2 ) \
{ \
Userwin *temp; \
temp = uwinp1; \
uwinp1 = uwinp2; \
uwinp2 = temp; \
}
/* ------------------------------------------------------------ */
#define COMPUTE_DISTANCE(pt1, pt2) \
(((Get_PtX(pt1) - Get_PtX(pt2)) * (Get_PtX(pt1) - Get_PtX(pt2))) + \
((Get_PtY(pt1) - Get_PtY(pt2)) * (Get_PtY(pt1) - Get_PtY(pt2))))
#define window_excursion(win,opt,val,code) \
{ \
bool temp_val; \
temp_val = Tilwin_Get_Window_Option(win,opt); \
Tilwin_Set_Window_Option(win,opt,val); \
code; \
Tilwin_Set_Window_Option(win,opt,temp_val); \
}
#define window_restrict_excursion(win,opt,val,code) \
{ \
bool temp_val; \
temp_val = Tilwin_Get_Window_Option(win,opt); \
Tilwin_Set_Window_Option( win, opt, (temp_val && val) ); \
code; \
Tilwin_Set_Window_Option(win,opt,temp_val); \
}
#define window_join_excursion(win,opt,val,code) \
{ \
bool temp_val; \
temp_val = Tilwin_Get_Window_Option(win,opt); \
Tilwin_Set_Window_Option( win, opt, (temp_val || val) ); \
code; \
Tilwin_Set_Window_Option(win,opt,temp_val); \
}
#define global_excursion(opt,val,code) \
{ \
bool temp_val; \
temp_val = Tilwin_Get_Global_Option(opt); \
Tilwin_Set_Global_Option(opt,val); \
code; \
Tilwin_Set_Global_Option(opt,temp_val); \
}
#define global_restrict_excursion(opt,val,code) \
{ \
bool temp_val; \
temp_val = Tilwin_Get_Global_Option(opt); \
Tilwin_Set_Global_Option( opt, (temp_val && val) ); \
code; \
Tilwin_Set_Global_Option(opt,temp_val); \
}
#define user_window_excursion(uwin,opt,val,code) \
{ \
bool temp_val; \
temp_val = Userwin_Get_Window_Option(uwin,opt); \
Userwin_Set_Window_Option( uwin, opt, val ); \
code; \
Userwin_Set_Window_Option(uwin,opt,temp_val); \
}
#define user_window_join_excursion(uwin,opt,val,code) \
{ \
bool temp_val; \
temp_val = Userwin_Get_Window_Option(uwin,opt); \
Userwin_Set_Window_Option( uwin, opt, (temp_val || val) ); \
code; \
Userwin_Set_Window_Option(uwin,opt,temp_val); \
}
#define user_global_excursion(opt,val,code) \
{ \
bool temp_val; \
temp_val = UserGlobals_Get_Option(opt); \
UserGlobals_Set_Option( opt, val ); \
code; \
UserGlobals_Set_Option(opt,temp_val); \
}
#define user_global_restrict_excursion(opt,val,code) \
{ \
bool temp_val; \
temp_val = UserGlobals_Get_Option(opt); \
UserGlobals_Set_Option( opt, (temp_val && val) ); \
code; \
UserGlobals_Set_Option(opt,temp_val); \
}
#define user_global_join_excursion(opt,val,code) \
{ \
bool temp_val; \
temp_val = UserGlobals_Get_Option(opt); \
UserGlobals_Set_Option( opt, (temp_val || val) ); \
code; \
UserGlobals_Set_Option(opt,temp_val); \
}
#define min_excursion(win,code) \
{ \
Size temp_min; \
temp_min = Tilwin_Get_Min(win); \
Tilwin_Set_Min( win, Tilwin_Get_Size(win) ); \
code; \
Tilwin_Set_Min( win, temp_min ); \
}
/* ------------------------------------------------------------ */
#define height_excursion(winp,code) \
{ \
if ( Tilwin_Get_Size(winp).height < \
Tilwin_Get_Previous_Size(winp).height ) \
window_excursion( winp, FIXED_HEIGHT, TRUE, code ) \
else \
{ \
Size temp_min; \
Size temp_siz; \
temp_siz = temp_min = Tilwin_Get_Min(winp); \
temp_siz.height = Tilwin_Get_Size(winp).height; \
Tilwin_Set_Min( winp, temp_siz ); \
code; \
Tilwin_Set_Min( winp, temp_min ); \
} \
}
/* ------------------------------------------------------------ */
#define width_excursion(winp,code) \
{ \
if ( Tilwin_Get_Size(winp).width < \
Tilwin_Get_Previous_Size(winp).width ) \
window_excursion( winp, FIXED_WIDTH, TRUE, code ) \
else \
{ \
Size temp_min; \
Size temp_siz; \
temp_siz = temp_min = Tilwin_Get_Min(winp); \
temp_siz.width = Tilwin_Get_Size(winp).width; \
Tilwin_Set_Min( winp, temp_siz ); \
code; \
Tilwin_Set_Min( winp, temp_min ); \
} \
}
static void Manage_Do_Unzoom(Userwin *uwinp, bool explicit);
static void Manage_Start_Trying();
static void Manage_Finish_Trying(bool result);
/* ------------------------------------------------------------ */
TimeStamp last_stamp;
static int winnum = 0;
Userwin *focus = UWIN_NULL;
Userwin *listener = UWIN_NULL;
Userwin *sublistener = UWIN_NULL;
Userwin *switch_listener = UWIN_NULL;
Userwin *prev_listener = UWIN_NULL;
Userwin *last_zoom = UWIN_NULL;
Userwin *touch = UWIN_NULL;
Userwin *prev_touch = UWIN_NULL;
Userwin *rtl_uwinp;
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Init()
{
Draw_Init();
Region_Init();
Drawwin_Init();
DrawIcon_Init();
last_stamp = 0;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static Userwin *Manage_Init_Window()
{
Userwin *uwinp;
uwinp = Userwin_Allocate;
uwinp->prepared = FALSE;
uwinp->layout = FALSE;
uwinp->layout_found = FALSE;
uwinp->output_sent = FALSE;
uwinp->ever_opened = FALSE;
uwinp->soft_kill = FALSE;
uwinp->saving_state = FALSE;
uwinp->client_state = NoState;
uwinp->wm_state = NeverState;
uwinp->group_state = GroupState;
uwinp->current_type = body;
uwinp->group = UWIN_NULL;
uwinp->messages = 0;
uwinp->hostname = NULL;
uwinp->res_class = NULL;
uwinp->res_name = NULL;
uwinp->wmname = NULL;
uwinp->iconname = NULL;
uwinp->command = NULL;
uwinp->identity = NULL;
uwinp->title = NULL;
uwinp->positioned = FALSE;
uwinp->sized = FALSE;
uwinp->focus = FALSE;
uwinp->listener = FALSE;
uwinp->zoomed = FALSE;
uwinp->icon_positioned = FALSE;
uwinp->winp = Tilwin_Create_Window( (pointer)uwinp );
uwinp->iconp = Tilwin_Create_Window( (pointer)uwinp );
uwinp->open_stamp = 0;
uwinp->zoom_stamp = 0;
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_LEFT_EDGE, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_RIGHT_EDGE, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_TOP_EDGE, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_BOTTOM_EDGE, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_SIZE, TRUE );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_COMPLETELY, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, EXPENSIVE_TO_REDRAW, FALSE );
Tilwin_Set_Window_Option( uwinp->iconp, REQUIRE_MANUAL_CLOSE, TRUE );
Profile_Create( uwinp );
return uwinp;
}
/* ------------------------------------------------------------ */
Userwin *Manage_Create_Window( )
{
Userwin *uwinp;
uwinp = Manage_Init_Window();
uwinp->winnum = ++winnum;
Drawwin_Create( uwinp );
DrawIcon_Create( uwinp );
return uwinp;
}
/* ------------------------------------------------------------ */
static void Manage_Untitle( uwinp )
Userwin *uwinp;
{
if ( (uwinp->hostname) != NULL )
free( uwinp->hostname );
if ( (uwinp->res_class) != NULL )
free( uwinp->res_class );
if ( (uwinp->res_name) != NULL )
free( uwinp->res_name );
if ( (uwinp->wmname) != NULL )
free( uwinp->wmname );
if ( (uwinp->iconname) != NULL )
free( uwinp->iconname );
if ( (uwinp->command) != NULL )
free( uwinp->command );
if ( (uwinp->identity) != NULL )
free( uwinp->identity );
if ( (uwinp->title) != NULL )
free( uwinp->title );
}
/* ------------------------------------------------------------ */
static void Manage_Retitle( uwinp )
Userwin *uwinp;
{
int strsiz;
bool has_class, has_name;
if ( (uwinp->title) != NULL )
free( uwinp->title );
strsiz = 1;
has_class = (uwinp->res_class != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_RES_CLASS_IN_TITLE );
has_name = (uwinp->res_name != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_RES_NAME_IN_TITLE );
if ( has_class || has_name )
{
strsiz +=1;
if ( has_class )
strsiz += strlen(uwinp->res_class);
if ( has_class && has_name )
strsiz +=1;
if ( has_name )
strsiz += strlen(uwinp->res_name);
strsiz +=2;
}
if ( (uwinp->wmname != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_NAME_IN_TITLE ) )
strsiz += strlen(uwinp->wmname);
if ( (uwinp->hostname != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_HOST_IN_TITLE ) )
strsiz += (3 + strlen(uwinp->hostname));
uwinp->title = allocate( char, strsiz );
uwinp->title[0] = '\0';
if ( has_class || has_name )
{
(void)strcat( uwinp->title, "[" );
if ( has_class )
(void)strcat( uwinp->title, uwinp->res_class );
if ( has_class && has_name )
(void)strcat( uwinp->title, ":" );
if ( has_name )
(void)strcat( uwinp->title, uwinp->res_name );
(void)strcat( uwinp->title, "] " );
}
if ( (uwinp->wmname != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_NAME_IN_TITLE ) )
{
(void)strcat( uwinp->title, uwinp->wmname );
}
if ( (uwinp->hostname != NULL) &&
Userwin_Get_Window_Option( uwinp, INCLUDE_HOST_IN_TITLE ) )
{
(void)strcat( uwinp->title, " (" );
(void)strcat( uwinp->title, uwinp->hostname );
(void)strcat( uwinp->title, ")" );
}
if ( Tilwin_Is_Open( uwinp->winp ) )
Drawwin_Retitle( uwinp );
else if ( uwinp->ever_opened )
{
Closed_Retitle( uwinp );
if ( Tilwin_Is_Open( uwinp->iconp ) )
DrawIcon_Retitle(uwinp);
}
}
/* ------------------------------------------------------------ */
void Manage_Set_Class( uwinp, res_class, res_name )
Userwin *uwinp;
char *res_class;
char *res_name;
{
if ( streql( uwinp->res_class, res_class ) &&
streql( uwinp->res_name, res_name ) )
return;
if ( (uwinp->res_class) != NULL )
free( uwinp->res_class );
if ( res_class == NULL )
uwinp->res_class = NULL;
else
{
uwinp->res_class =
allocate( char, 1 + strlen(res_class) );
(void)strcpy( uwinp->res_class, res_class );
}
if ( (uwinp->res_name) != NULL )
free( uwinp->res_name );
if ( res_name == NULL )
uwinp->res_name = NULL;
else
{
uwinp->res_name =
allocate( char, 1 + strlen(res_name) );
(void)strcpy( uwinp->res_name, res_name );
}
Profile_Prepare( uwinp );
uwinp->prepared = TRUE;
Manage_Retitle( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Set_Name( uwinp, str )
Userwin *uwinp;
char *str;
{
if ( (uwinp->wmname) != NULL )
free( uwinp->wmname );
uwinp->wmname = allocate( char, 1 + strlen(str) );
(void)strcpy( uwinp->wmname, str );
if ( uwinp->identity == NULL )
{
uwinp->identity = allocate( char, 1 + strlen(str) );
(void)strcpy( uwinp->identity, str );
}
Manage_Retitle( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Set_Icon_Name( uwinp, str )
Userwin *uwinp;
char *str;
{
if ( (uwinp->iconname) != NULL )
free( uwinp->iconname );
uwinp->iconname = allocate( char, 1 + strlen(str) );
(void)strcpy( uwinp->iconname, str );
Manage_Retitle( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Set_Hostname( uwinp, str )
Userwin *uwinp;
char *str;
{
if ( (uwinp->hostname) != NULL )
free( uwinp->hostname );
uwinp->hostname = allocate( char, 1 + strlen(str) );
(void)strcpy( uwinp->hostname, str );
Manage_Retitle( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Set_Command( uwinp, str )
Userwin *uwinp;
char *str;
{
if ( uwinp->soft_kill )
{
extern void Manage_Client_Destroy();
Manage_Client_Destroy( uwinp );
return;
}
uwinp->saving_state = FALSE;
if ( (uwinp->command) != NULL )
free( uwinp->command );
uwinp->command = allocate( char, 1 + strlen(str) );
(void)strcpy( uwinp->command, str );
Manage_Retitle( uwinp );
}
/* ------------------------------------------------------------ */
static void Manage_Prepare( uwinp )
Userwin *uwinp;
{
if ( (uwinp->res_class == NULL) && (uwinp->res_name == NULL) &&
(uwinp->wmname != NULL) )
Manage_Set_Class( uwinp, uwinp->wmname, NULL );
}
/* ------------------------------------------------------------ */
void Manage_Layout( uwinp )
Userwin *uwinp;
{
if (! uwinp->prepared)
Manage_Prepare( uwinp );
Profile_Layout( uwinp );
uwinp->layout = TRUE;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
Userwin *Manage_Locate(pos)
TWPoint pos;
{
return Userwin_Get(Tilwin_Locate(pos));
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Set_Focus( uwinp )
Userwin *uwinp;
{
focus = uwinp;
if (focus != UWIN_NULL)
{
focus->focus = TRUE;
if ( Tilwin_Is_Open( focus->winp ) )
Drawwin_Display_Focus( focus );
}
}
/* ------------------------------------------------------------ */
void Manage_Unset_Focus()
{
if (focus != UWIN_NULL)
{
focus->focus = FALSE;
if ( Tilwin_Is_Open( focus->winp ) )
Drawwin_Display_Focus( focus );
focus = UWIN_NULL;
}
}
/* ------------------------------------------------------------ */
void Manage_Switch_Focus( uwinp )
Userwin *uwinp;
{
if ( uwinp != focus )
{
Manage_Unset_Focus();
Manage_Set_Focus( uwinp );
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
#define Manage_Global_Client_Restrict(op) \
global_restrict_excursion( ALLOW_AUTOMATIC_SHRINK, \
UserGlobals_Get_Option(ALLOW_AUTOMATIC_SHRINK_BY_CLIENT), \
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE, \
UserGlobals_Get_Option(ALLOW_AUTOMATIC_CLOSE_BY_CLIENT), op ) )
/* ------------------------------------------------------------ */
#define Manage_Client_Restrict(uwinp,op) \
window_join_excursion( uwinp->winp, REQUIRE_MANUAL_CLOSE, \
(! UserGlobals_Get_Option(ALLOW_LSNR_TO_CLOSE_BY_CLIENT)), \
{ window_join_excursion( uwinp->winp, FIXED_COMPLETELY, \
( uwinp->focus && \
(! UserGlobals_Get_Option(ALLOW_LSNR_TO_CHANGE_BY_CLIENT))), \
Manage_Global_Client_Restrict( op ) ) } ) \
/* ------------------------------------------------------------ */
#define Manage_Client(op) \
{ \
Userwin *cur_listener; \
Userwin *cur_sublistener; \
cur_listener = listener; \
cur_sublistener = sublistener; \
if ( sublistener != UWIN_NULL ) \
{ \
if ( listener != UWIN_NULL ) \
window_join_excursion( cur_listener->winp, REQUIRE_MANUAL_CLOSE, \
(! UserGlobals_Get_Option(ALLOW_LSNR_TO_CLOSE_BY_CLIENT)), \
Manage_Client_Restrict( cur_sublistener, op ) ) \
else \
Manage_Client_Restrict( cur_sublistener, op ) \
} \
else \
{ \
if ( listener != UWIN_NULL ) \
Manage_Client_Restrict( cur_listener, op ) \
else \
Manage_Global_Client_Restrict( op ) \
} \
}
/* ------------------------------------------------------------ */
void Manage_Set_Sublistener( uwinp )
Userwin *uwinp;
{
sublistener = uwinp;
if ( Userwin_Get_Window_Option( sublistener, NOTE_LISTENER ) )
Tilwin_Note_Use( sublistener->winp );
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
{
sublistener->regular_manual_close =
Tilwin_Get_Window_Option( sublistener->winp, REQUIRE_MANUAL_CLOSE );
Tilwin_Set_Window_Option( sublistener->winp, REQUIRE_MANUAL_CLOSE, TRUE );
}
}
/* ------------------------------------------------------------ */
void Manage_Unset_Sublistener()
{
if ( sublistener != UWIN_NULL )
{
if ( ( listener != UWIN_NULL ) &&
Userwin_Get_Window_Option( listener, NOTE_LISTENER ) )
Tilwin_Note_Use( listener->winp );
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
Tilwin_Set_Window_Option( sublistener->winp, REQUIRE_MANUAL_CLOSE,
sublistener->regular_manual_close );
sublistener = UWIN_NULL;
}
}
/* ------------------------------------------------------------ */
void Manage_Switch_Sublistener( uwinp )
Userwin *uwinp;
{
if ( uwinp != sublistener )
{
Manage_Unset_Sublistener();
if ( uwinp != UWIN_NULL )
Manage_Set_Sublistener( uwinp );
}
}
/* ------------------------------------------------------------ */
static void Manage_Set_Listener( uwinp )
Userwin *uwinp;
{
listener = uwinp;
if ( listener != UWIN_NULL )
{
Manage_Unset_Sublistener();
listener->listener = TRUE;
Tilwin_Act_Modified( listener->winp );
if ( Userwin_Get_Window_Option( listener, NOTE_LISTENER ) )
Tilwin_Note_Use( listener->winp );
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
{
listener->regular_manual_close =
Tilwin_Get_Window_Option( listener->winp, REQUIRE_MANUAL_CLOSE );
Tilwin_Set_Window_Option( listener->winp,
REQUIRE_MANUAL_CLOSE, TRUE );
}
}
}
/* ------------------------------------------------------------ */
static void Manage_Unset_Listener()
{
listener->listener = FALSE;
Tilwin_Act_Modified( listener->winp );
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
Tilwin_Set_Window_Option( listener->winp, REQUIRE_MANUAL_CLOSE,
listener->regular_manual_close );
listener = UWIN_NULL;
}
/* ------------------------------------------------------------ */
static void Manage_Unset( uwinp )
Userwin *uwinp;
{
extern void Manage_Do_Unzoom();
if ( uwinp == focus )
Manage_Unset_Focus();
if ( uwinp == listener )
{
if ( Userwin_Get_Window_Option(listener,LISTENER_TIED_TO_ZOOM) &&
listener->zoomed )
Manage_Do_Unzoom( listener, FALSE );
Manage_Unset_Listener();
}
else if ( uwinp == sublistener )
Manage_Unset_Sublistener();
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
TWRectangle Manage_Neighborhood_Rectangle( nbhd, center, siz )
float nbhd;
TWPoint center;
Size siz;
{
TWRectangle rect;
int horiz, vert;
int dhoriz, dvert;
int factor;
factor = UserGlobals_Get_Value( NEIGHBORHOOD_SHRINK_FACTOR );
dhoriz = 100 * Tilwin_Get_Desktop_Size().width;
dvert = 100 * Tilwin_Get_Desktop_Size().height;
horiz = nbhd * siz.width * (dhoriz - (factor*siz.width)) / dhoriz;
horiz += (siz.width/2);
rect.left_x = center.x - horiz;
rect.right_x = center.x + horiz;
vert = nbhd * siz.height * (dvert - (factor*siz.height)) / dvert;
vert += (siz.height/2);
rect.top_y = center.y - vert;
rect.bottom_y = center.y + vert;
return rect;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool Manage_Neighborhood_Icon_Open( uwinp, center )
Userwin *uwinp;
TWPoint center;
{
TWRectangle rect;
Size siz;
bool result;
extern void Manage_Start_Trying();
extern bool Manage_Can_Try_Listener_Unzoom();
extern void Manage_Finish_Trying();
siz = Tilwin_Get_Size( uwinp->iconp );
Manage_Start_Trying();
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE, FALSE,
{
result = Tilwin_Open( uwinp->iconp, center, siz );
if ( (! result) && Manage_Can_Try_Listener_Unzoom() )
result = Tilwin_Open( uwinp->iconp, center, siz );
} )
Manage_Finish_Trying( result );
if ( result ) return TRUE;
rect = Manage_Neighborhood_Rectangle( 0.75, center, siz );
return Tilwin_Open_Nearest_In_Area( uwinp->iconp, rect, center, siz );
}
/* ------------------------------------------------------------ */
bool Manage_Icon_Open( uwinp )
Userwin *uwinp;
{
TWRectangle desk,iconarea, rect, area, bigger_area;
TWPoint center;
Size siz;
bool first_none = FALSE;
bool second_none = FALSE;
bool icon_positioned;
bool result;
if ( ( uwinp->client_state == InactiveState ) ||
( uwinp->client_state == IgnoreState ) ||
( Userwin_Group_Closed(uwinp) &&
( uwinp->group != uwinp ) ) ||
( ! Userwin_Get_Window_Option( uwinp, SHOW_ICON ) ) )
return FALSE;
if ( (uwinp->icon_positioned) &&
Userwin_Get_Window_Option( uwinp,
REQUIRE_PREVIOUS_ICON_POSITION ) )
{
if ( Manage_Neighborhood_Icon_Open( uwinp,
Tilwin_Get_Position( uwinp->iconp ) ) )
return TRUE;
}
icon_positioned = (uwinp->icon_positioned) &&
( Userwin_Get_Window_Option( uwinp,
PREFER_PREVIOUS_ICON_POSITION ) ||
Userwin_Get_Window_Option( uwinp,
REQUIRE_PREVIOUS_ICON_POSITION ) );
siz = Tilwin_Get_Size( uwinp->iconp );
desk = Tilwin_Get_Desktop_Rectangle();
if ( UserGlobals_Get_Option( USE_ICON_AREA ) )
{
iconarea.left_x = UserGlobals_Get_Value( ICON_AREA_LEFT );
iconarea.right_x = UserGlobals_Get_Value( ICON_AREA_RIGHT );
iconarea.top_y = UserGlobals_Get_Value( ICON_AREA_TOP );
iconarea.bottom_y = UserGlobals_Get_Value( ICON_AREA_BOTTOM );
}
else
iconarea = desk;
bigger_area = area = rect = iconarea;
switch ( (Icon_Position)UserGlobals_Get_Value(
SECONDARY_ICON_PLACEMENT) )
{
case Icon_Top:
rect.bottom_y = iconarea.top_y + siz.height - 1;
break;
case Icon_Bottom:
rect.top_y = iconarea.bottom_y - siz.height + 1;
break;
case Icon_Left:
rect.right_x = iconarea.left_x + siz.width - 1;
break;
case Icon_Right:
rect.left_x = iconarea.right_x - siz.width + 1;
break;
case Icon_None:
second_none = TRUE;
case Icon_Middle:
default:
break;
}
switch ( (Icon_Position)UserGlobals_Get_Value(ICON_PLACEMENT) )
{
case Icon_None:
first_none = TRUE;
default:
break;
case Icon_Top:
rect.top_y = iconarea.top_y;
rect.bottom_y = iconarea.top_y + siz.height - 1;
area.bottom_y = iconarea.top_y + siz.height - 1;
bigger_area.bottom_y = iconarea.top_y + (2* siz.height) - 1;
break;
case Icon_Bottom:
rect.bottom_y = iconarea.bottom_y;
rect.top_y = iconarea.bottom_y - siz.height + 1;
area.top_y = iconarea.bottom_y - siz.height + 1;
bigger_area.top_y = iconarea.bottom_y - (2*siz.height) + 1;
break;
case Icon_Left:
rect.left_x = iconarea.left_x;
rect.right_x = iconarea.left_x + siz.width - 1;
area.right_x = iconarea.left_x + siz.width - 1;
bigger_area.right_x = iconarea.left_x + (2*siz.width) - 1;
break;
case Icon_Right:
rect.right_x = iconarea.right_x;
rect.left_x = iconarea.right_x - siz.width + 1;
area.left_x = iconarea.right_x - siz.width + 1;
bigger_area.left_x = iconarea.right_x - (2*siz.width) + 1;
break;
}
COMPUTE_CENTER( rect, center );
if ( icon_positioned )
{
center = Tilwin_Get_Position( uwinp->iconp );
if ( first_none )
result = Manage_Neighborhood_Icon_Open( uwinp, center );
else
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
area, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
iconarea, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
desk, center, siz );
}
else if ( first_none )
{
result = Tilwin_Open_Best_In_Area( uwinp->iconp,
iconarea, siz );
if (! result)
result = Tilwin_Open_Best_In_Area( uwinp->iconp,
desk, siz );
}
else if (second_none)
{
result = Tilwin_Open_Best_In_Area( uwinp->iconp,
area, siz );
if (! result)
result = Tilwin_Open_Best_In_Area( uwinp->iconp,
bigger_area, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
iconarea, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
desk, center, siz );
}
else
{
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
area, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
bigger_area, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
iconarea, center, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->iconp,
desk, center, siz );
}
if ( result && !uwinp->icon_positioned )
{
uwinp->icon_positioned = TRUE;
Tilwin_Set_Position( uwinp->iconp,
Tilwin_Get_Center( uwinp->iconp ) );
}
return result;
}
/* ------------------------------------------------------------ */
void Manage_Update_Icons()
{
Tilwinp winp;
Userwin *uwinp;
bool keep_updating;
if ( UserGlobals_Get_Option(USE_ICONS) )
{
Tilwin_Gen_Just_Opened_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( uwinp->winp == winp ) && Tilwin_Is_Open( uwinp->iconp ) )
Tilwin_Close( uwinp->iconp );
}
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( uwinp->winp == winp ) && Tilwin_Is_Open( uwinp->iconp ) )
Tilwin_Close( uwinp->iconp );
}
keep_updating = TRUE;
while ( keep_updating )
{
keep_updating = FALSE;
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( uwinp->iconp == winp )
&& ( ! Tilwin_Is_Open( uwinp->winp ) )
&& uwinp->ever_opened )
keep_updating |= Manage_Icon_Open( uwinp );
}
}
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool drawing = FALSE;
static bool redrawing = FALSE;
/* ------------------------------------------------------------ */
static void Manage_Update_Desktop()
{
Tilwinp winp;
Userwin *uwinp;
Drawwin_Start();
Tilwin_Gen_Just_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->current_type == body )
{
Manage_Unset( uwinp );
Drawwin_Close( uwinp,
(! Tilwin_Is_Covered(
Tilwin_Get_Previous_Rectangle( winp ) ) ) );
uwinp->output_sent = FALSE;
if ( ( uwinp->client_state != IgnoreState ) &&
( uwinp->client_state != NeverState ) )
Closed_Add( uwinp );
}
else
{
DrawIcon_Close( uwinp );
}
if (! ( Tilwin_Is_Open(uwinp->winp) ||
Tilwin_Is_Open(uwinp->iconp) ) )
{
if ( uwinp->client_state == IgnoreState )
uwinp->wm_state = IgnoreState;
else
uwinp->wm_state = InactiveState;
/* Window may be destroyed or rtl icon */
if ( uwinp->client_state != NeverState )
Client_Set_State( uwinp );
}
}
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( ! uwinp->positioned ) &&
( uwinp->current_type == body ) )
Tilwin_Set_Position( winp,
Tilwin_Get_Center( winp ) );
}
if ( drawing )
{
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->current_type == body )
Drawwin_Draw( uwinp );
else
DrawIcon_Draw( uwinp );
}
}
else
{
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
if ( Tilwin_Was_Actually_Modified(winp) || redrawing )
{
uwinp = Userwin_Get(winp);
if ( uwinp->current_type != body )
DrawIcon_Move_Close( uwinp );
else if ( uwinp == switch_listener )
Drawwin_Listener_Move_Close( uwinp,
(! Tilwin_Is_Covered(
Tilwin_Get_Previous_Rectangle( winp ) ) ) );
else
Drawwin_Move_Close( uwinp,
(! Tilwin_Is_Covered(
Tilwin_Get_Previous_Rectangle( winp ) ) ) );
}
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( Tilwin_Was_Actually_Modified(winp) || redrawing )
{
if ( uwinp->current_type != body )
{
DrawIcon_Move_Open( uwinp );
if ( redrawing )
DrawIcon_Redraw( uwinp );
}
else if ( uwinp == switch_listener )
Drawwin_Listener_Move_Open( uwinp );
else
{
Drawwin_Move_Open( uwinp );
if ( redrawing )
Drawwin_Retitle( uwinp );
}
}
}
if ( listener != prev_listener )
{
if ( ( listener != UWIN_NULL ) &&
Tilwin_Was_Just_Modified( listener->winp ) &&
(! Tilwin_Was_Actually_Modified( listener->winp )) &&
( listener->current_type == body ) )
Drawwin_Display_Wrapping( listener );
if ( ( prev_listener != UWIN_NULL ) &&
Tilwin_Was_Just_Modified( prev_listener->winp ) &&
(! Tilwin_Was_Actually_Modified( prev_listener->winp )) &&
( prev_listener->current_type == body ) )
Drawwin_Display_Wrapping( prev_listener );
}
else
{
if ( ( touch != UWIN_NULL ) &&
Tilwin_Was_Just_Modified( touch->winp ) &&
(! Tilwin_Was_Actually_Modified( touch->winp )) &&
( touch->current_type == body ) )
Drawwin_Display_Wrapping( touch );
}
}
Tilwin_Gen_Just_Opened_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( winp == uwinp->winp )
{
uwinp->current_type = body;
uwinp->sized = TRUE;
if ( ! uwinp->positioned )
Tilwin_Set_Position( winp,
Tilwin_Get_Center( winp ) );
Drawwin_Open( uwinp );
Closed_Remove( uwinp );
uwinp->wm_state = NormalState;
}
else
{
if ( uwinp != rtl_uwinp )
uwinp->current_type = icon;
DrawIcon_Open( uwinp );
if ( Userwin_Get_Window_Option( uwinp, CLIENT_DRAWS_ICON ) )
uwinp->wm_state = ClientIconState;
else
uwinp->wm_state = IconicState;
}
if ( uwinp->current_type != rtl )
Client_Set_State( uwinp );
}
if (! drawing )
{
Tilwin_Gen_Just_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->winp == winp )
Drawwin_Unmap( uwinp );
}
}
Drawwin_Finish();
switch_listener = UWIN_NULL;
prev_touch = touch;
touch = UWIN_NULL;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Save_State( uwinp )
Userwin *uwinp;
{
uwinp->undo_stamp = Tilwin_Get_Timestamp();
uwinp->prev_positioned = uwinp->positioned;
uwinp->prev_sized = uwinp->sized;
uwinp->prev_zoomed = uwinp->zoomed;
uwinp->prev_group_state = uwinp->group_state;
uwinp->prev_desire = Tilwin_Get_Desired( uwinp->winp );
uwinp->prev_min = Tilwin_Get_Min( uwinp->winp );
uwinp->prev_max = Tilwin_Get_Max( uwinp->winp );
uwinp->prev_rezoom_rect = uwinp->rezoom_rect;
}
/* ------------------------------------------------------------ */
static void Manage_Exchange_State( uwinp )
Userwin *uwinp;
{
Size temp_size;
if ( last_stamp != uwinp->undo_stamp )
return;
SWAP_BOOL( uwinp->prev_positioned, uwinp->positioned )
SWAP_BOOL( uwinp->prev_sized, uwinp->sized )
SWAP_BOOL( uwinp->prev_zoomed, uwinp->zoomed )
SWAP_INT( uwinp->prev_group_state, uwinp->group_state )
SWAP_RECT( uwinp->prev_rezoom_rect, uwinp->rezoom_rect )
temp_size = Tilwin_Get_Desired( uwinp->winp );
Tilwin_Set_Desired( uwinp->winp, uwinp->prev_desire );
uwinp->prev_desire = temp_size;
temp_size = Tilwin_Get_Min( uwinp->winp );
Tilwin_Set_Min( uwinp->winp, uwinp->prev_min );
uwinp->prev_min = temp_size;
temp_size = Tilwin_Get_Max( uwinp->winp );
Tilwin_Set_Max( uwinp->winp, uwinp->prev_max );
uwinp->prev_max = temp_size;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static void Manage_Cant_Undo()
{
prev_listener = listener;
Tilwin_Start_Transaction();
Tilwin_Commit_Transaction();
last_stamp = Tilwin_Get_Timestamp();
}
/* ------------------------------------------------------------ */
void Manage_Start()
{
if ( Tilwin_Transaction_Depth() == 0 )
prev_listener = listener;
Tilwin_Start_Transaction();
}
/* ------------------------------------------------------------ */
static void Manage_Restart()
{
Tilwin_Abort_Transaction();
Tilwin_Start_Transaction();
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
extern bool Manage_Repopulate_Since();
extern bool Manage_Aggressive_Repopulation();
/* ------------------------------------------------------------ */
static bool Manage_Unzoom_Repopulation()
{
TimeStamp repop_since;
Tilwinp winp;
Userwin *uwinp;
bool result = FALSE;
repop_since = last_stamp;
Tilwin_Gen_Just_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( uwinp->current_type == body ) &&
( ( uwinp->zoomed ) ||
( ( uwinp->undo_stamp == last_stamp ) &&
( uwinp->prev_zoomed ) ) ) )
{
if (! UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_AUTO_UNZOOM) )
repop_since = (TimeStamp)0;
else if ( uwinp->zoom_stamp < repop_since )
repop_since = uwinp->zoom_stamp;
}
}
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( ( uwinp->current_type == body ) &&
(! uwinp->zoomed ) &&
( uwinp->undo_stamp == last_stamp ) &&
( uwinp->prev_zoomed ) )
{
if (! UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_AUTO_UNZOOM) )
repop_since = (TimeStamp)0;
else if ( uwinp->zoom_stamp < repop_since )
repop_since = uwinp->zoom_stamp;
}
}
if ( repop_since < last_stamp )
{
user_global_join_excursion(
REQUIRE_PREV_POS_ON_AUTO_REPOP, TRUE,
{
if ( Manage_Repopulate_Since(
repop_since, FALSE, FALSE, TRUE ) )
result = TRUE;
} )
if ( Manage_Repopulate_Since(
repop_since, FALSE, FALSE, TRUE ) )
result = TRUE;
}
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Finish_Repopulation()
{
bool result;
result = FALSE;
if ( UserGlobals_Get_Option(AUTO_REPOPULATE_LAST) )
if ( Manage_Repopulate_Since(
last_stamp, FALSE, FALSE, TRUE ) )
result = TRUE;
if ( UserGlobals_Get_Option(ALLOW_AGGRESSIVE_REPOPULATION) )
if ( Manage_Aggressive_Repopulation() )
result = TRUE;
if ( UserGlobals_Get_Option(
AUTO_REPOPULATE_ON_AUTO_UNZOOM) )
global_excursion( ALLOW_AUTOMATIC_SHRINK, FALSE,
{
if ( Manage_Unzoom_Repopulation() )
result = TRUE;
} )
return result;
}
/* ------------------------------------------------------------ */
extern void Manage_Auto_Prorate();
extern void Manage_Ordered_Desire();
void Manage_Finish( result )
bool result;
{
extern void Manage_Ordered_Desire();
bool allow_repop_shrink, can_repop, can_size;
if ( Tilwin_Transaction_Depth() > 1 )
Tilwin_Commit_Transaction();
else if (! result)
{
Tilwin_Abort_Transaction();
Draw_Flash();
}
else
{
last_stamp = Tilwin_Get_Timestamp();
allow_repop_shrink =
Tilwin_Get_Global_Option(ALLOW_AUTOMATIC_SHRINK) &&
Tilwin_Get_Global_Option(ALLOW_AUTO_SHRINK_MORE_RECENT) &&
UserGlobals_Get_Option(
ALLOW_AUTO_SHRINK_ON_AUTO_REPOP);
can_repop = Layout_Done() ||
UserGlobals_Get_Option( ENABLE_AUTO_REPOP_DURING_LAYOUT );
can_size = Layout_Done() ||
UserGlobals_Get_Option( ENABLE_AUTO_SIZING_DURING_LAYOUT );
Manage_Update_Icons();
if ( allow_repop_shrink && can_size &&
UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Manage_Ordered_Desire();
if ( can_repop && Manage_Finish_Repopulation() )
Manage_Update_Icons();
if ( can_size &&
UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Manage_Ordered_Desire();
if ( can_size &&
UserGlobals_Get_Option(AUTO_PRORATE) )
while ( TRUE )
{
Manage_Auto_Prorate();
if ( can_size &&
UserGlobals_Get_Option(
TRY_REPOP_AGAIN_AFT_AUTO_PRORATE) &&
Manage_Finish_Repopulation() )
Manage_Update_Icons();
else
break;
}
Manage_Update_Desktop();
Tilwin_Commit_Transaction();
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
bool Manage_Finish_Fixed_Completely( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result && ( uwinp != UWIN_NULL ) )
window_excursion( uwinp->winp, FIXED_COMPLETELY, TRUE,
Manage_Finish( TRUE ) )
else
Manage_Finish( result );
return result;
}
/* ------------------------------------------------------------ */
bool Manage_Finish_Fixed_Size( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result && ( uwinp != UWIN_NULL ) )
window_excursion( uwinp->winp, FIXED_SIZE, TRUE,
Manage_Finish( TRUE ) )
else
Manage_Finish( result );
return result;
}
/* ------------------------------------------------------------ */
bool Manage_Finish_Locked( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result && ( uwinp != UWIN_NULL ) )
window_excursion( uwinp->winp, REQUIRE_MANUAL_CLOSE, TRUE,
Manage_Finish( TRUE ) )
else
Manage_Finish( result );
return result;
}
/* ------------------------------------------------------------ */
bool Manage_Finish_Minned( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result && ( uwinp != UWIN_NULL ) )
min_excursion( uwinp->winp,
window_excursion( uwinp->winp, REQUIRE_MANUAL_CLOSE, TRUE,
Manage_Finish( TRUE ) ) )
else
Manage_Finish( result );
return result;
}
/* ------------------------------------------------------------ */
#define Manage_Client_Finish_Minned(uwinp,op) \
Manage_Client( \
{ \
op; \
Manage_Finish_Minned( uwinp, TRUE ); \
} )
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static void Manage_Undo_Start()
{
Tilwinp winp;
Userwin *uwinp;
Tilwin_Undo();
Tilwin_Gen_Just_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->winp == winp )
Manage_Exchange_State( uwinp );
}
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->winp == winp )
Manage_Exchange_State( uwinp );
}
Tilwin_Gen_Just_Opened_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->winp == winp )
Manage_Exchange_State( uwinp );
}
Tilwin_Continue_Transaction();
if ( listener != prev_listener )
{
if ( listener != UWIN_NULL )
{
listener->listener = FALSE;
Tilwin_Act_Modified( listener->winp );
}
SWAP_UWINP( listener, prev_listener )
touch = prev_touch;
if ( listener != UWIN_NULL )
{
listener->listener = TRUE;
Tilwin_Act_Modified( listener->winp );
}
}
}
/* ------------------------------------------------------------ */
void Manage_Undo()
{
Tilwinp winp;
Userwin *uwinp;
Manage_Undo_Start();
if ( UserGlobals_Get_Option(USE_ICONS) )
{
Tilwin_Gen_Just_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if (! ( Tilwin_Is_Open( uwinp->winp ) ||
Tilwin_Is_Open( uwinp->iconp ) ) )
Manage_Icon_Open( uwinp );
}
}
user_global_excursion( AUTO_PRORATE, FALSE,
user_global_excursion( AUTO_REPOPULATE_LAST, FALSE,
user_global_excursion( ALLOW_AGGRESSIVE_REPOPULATION, FALSE,
Manage_Finish( TRUE )
) ) )
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Redraw( uwinp )
Userwin *uwinp;
{
if ( uwinp->current_type == body )
Drawwin_Redraw(uwinp);
else
DrawIcon_Redraw(uwinp);
}
/* ------------------------------------------------------------ */
void Manage_Redraw_All()
{
Tilwinp winp;
if ( Drawwin_Redraw_All( Tilwin_Get_Desktop_Rectangle() ) )
return;
Tilwin_Gen_Open_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
Manage_Redraw( Userwin_Get(winp) );
}
/* ------------------------------------------------------------ */
void Manage_Finish_Layout()
{
Manage_Start();
Layout_Finish();
Manage_Finish( TRUE );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Initial_Icon_Open( uwinp )
Userwin *uwinp;
{
Manage_Start();
Tilwin_Note_Use( uwinp->winp );
if ( uwinp->client_state != IgnoreState )
{
Closed_Add( uwinp );
if ( UserGlobals_Get_Option(USE_ICONS) )
{
if (! uwinp->layout_found )
Manage_Icon_Open( uwinp );
else
global_excursion( ENABLE_GRAVITY, FALSE,
user_window_excursion( uwinp,
REQUIRE_PREVIOUS_ICON_POSITION, TRUE,
Manage_Icon_Open( uwinp ) ) )
}
}
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Prepare_Open( uwinp )
Userwin *uwinp;
{
if (! uwinp->layout)
Manage_Layout( uwinp );
Tilwin_Set_Position( uwinp->winp,
Tilwin_Get_Center( uwinp->winp ) );
Tilwin_Set_Position( uwinp->iconp,
Tilwin_Get_Center( uwinp->iconp ) );
Drawwin_Insert( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Note_Output( uwinp )
Userwin *uwinp;
{
if (! uwinp->layout)
Manage_Layout( uwinp );
if ( Tilwin_Is_Open( uwinp->winp ) )
{
if ( Userwin_Get_Window_Option( uwinp, NOTE_OPEN_OUTPUT ) )
Tilwin_Note_Use( uwinp->winp );
}
else if ( Userwin_Get_Window_Option( uwinp, NOTE_CLOSED_OUTPUT ) )
Tilwin_Note_Use( uwinp->winp );
if (! uwinp->output_sent)
{
uwinp->output_sent = TRUE;
if ( Tilwin_Is_Open(uwinp->iconp) )
DrawIcon_Note_Output( uwinp );
}
}
/* ------------------------------------------------------------ */
void Manage_Note_Input( uwinp )
Userwin *uwinp;
{
if ( Tilwin_Is_Open( uwinp->winp ) )
{
if ( Userwin_Get_Window_Option( uwinp, NOTE_OPEN_INPUT ) )
Tilwin_Note_Use( uwinp->winp );
else if ( ( uwinp == listener ) &&
Userwin_Get_Window_Option( uwinp, NOTE_LISTENER_INPUT ) )
Tilwin_Note_Use( uwinp->winp );
}
else if ( Userwin_Get_Window_Option( uwinp, NOTE_CLOSED_INPUT ) )
Tilwin_Note_Use( uwinp->winp );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Init_Rtl()
{
Userwin *uwinp;
Manage_Start();
uwinp = Manage_Init_Window();
rtl_uwinp = uwinp;
uwinp->winnum = 0;
uwinp->connection = -1;
uwinp->client_state = NeverState;
uwinp->current_type = rtl;
uwinp->layout = TRUE;
uwinp->layout_found = TRUE;
Userwin_Set_Window_Option( uwinp, SHOW_ICON,
UserGlobals_Get_Option(USE_RTL_ICON) );
Tilwin_Set_Window_Option( uwinp->iconp, FIXED_SIZE, TRUE );
Userwin_Set_Window_Option( uwinp, SAVE_IN_LAYOUT, FALSE );
Userwin_Set_Window_Option( uwinp, CONSIDER_FOR_REPOPULATION, FALSE );
DrawIcon_Init_Rtl( uwinp );
if ( UserGlobals_Get_Option(USE_ICONS) )
Manage_Icon_Open( uwinp );
Manage_Finish( TRUE );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Start_Repaint()
{
Tilwin_Start_Transaction();
}
/* ------------------------------------------------------------ */
void Manage_Repaint_Rect( rect )
TWRectangle rect;
{
Tilwin_Modify_Covered_Windows( rect );
Drawwin_Draw_Background( rect );
}
/* ------------------------------------------------------------ */
void Manage_Finish_Repaint()
{
Tilwinp winp;
Tilwin_Commit_Transaction();
Tilwin_Gen_Just_Modified_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
Manage_Redraw( Userwin_Get(winp) );
}
Manage_Cant_Undo();
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Set_Desktop_Size( desksiz )
Size desksiz;
{
Tilwin_Set_Desktop_Size( desksiz );
Drawwin_Draw_Background( Tilwin_Get_Desktop_Rectangle() );
}
/* ------------------------------------------------------------ */
static void Manage_Reorganize_Desktop( desksiz )
Size desksiz;
{
Tilwinp winp, head, middle, tail;
Userwin *uwinp;
TWPoint center;
TWPoint pos;
TWRectangle rect;
Size siz;
Size old_desksiz;
TWRectangle old_deskrect, deskrect;
head = middle = tail = WIN_NULL;
Tilwin_Gen_Open_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->current_type != body )
{
if ( UserGlobals_Get_Option(USE_ICONS) &&
( uwinp != rtl_uwinp ) )
{
if ( tail == WIN_NULL ) tail = winp;
if ( middle == WIN_NULL ) middle = winp;
Tilwin_Put_Data( winp, head );
head = winp;
}
}
else if ( Tilwin_Get_Window_Option( winp, REQUIRE_MANUAL_CLOSE ) )
{
if ( middle == WIN_NULL )
{
if ( tail == WIN_NULL ) tail = winp;
Tilwin_Put_Data( winp, head );
head = winp;
middle = winp;
}
else if ( middle == tail )
{
Tilwin_Put_Data( tail, winp );
Tilwin_Put_Data( winp, WIN_NULL );
tail = winp;
middle = winp;
}
else
{
Tilwin_Put_Data( winp, Tilwin_Get_Data( middle ) );
Tilwin_Put_Data( middle, winp );
middle = winp;
}
}
else
{
if ( head == WIN_NULL )
head = winp;
else
Tilwin_Put_Data( tail, winp );
Tilwin_Put_Data( winp, WIN_NULL );
tail = winp;
}
Tilwin_Auto_Close( winp );
}
old_desksiz = Tilwin_Get_Desktop_Size();
old_deskrect = Tilwin_Get_Desktop_Rectangle();
Tilwin_Set_Desktop_Size( desksiz );
desksiz = Tilwin_Get_Desktop_Size();
deskrect = Tilwin_Get_Desktop_Rectangle();
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->winp == winp )
Manage_Retitle( uwinp );
center = Tilwin_Get_Center( winp );
pos = Tilwin_Get_Position( winp );
rect = Tilwin_Get_Rectangle( winp );
siz = Tilwin_Get_Size( winp );
if ( desksiz.width < old_desksiz.width )
{
siz.width = ( siz.width * desksiz.width ) /
old_desksiz.width;
center.x = ( center.x * desksiz.width ) /
old_desksiz.width;
pos.x = ( pos.x * desksiz.width ) /
old_desksiz.width;
}
else if ( rect.right_x == old_deskrect.right_x )
{
center.x += ( desksiz.width - old_desksiz.width );
pos.x += ( desksiz.width - old_desksiz.width );
}
else if ( rect.left_x != 0 )
{
center.x = ( center.x * desksiz.width ) /
old_desksiz.width;
pos.x = ( pos.x * desksiz.width ) /
old_desksiz.width;
}
if ( desksiz.height < old_desksiz.height )
{
siz.height = ( siz.height * desksiz.height ) /
old_desksiz.height;
center.y = ( center.y * desksiz.height ) /
old_desksiz.height;
pos.y = ( pos.y * desksiz.height ) /
old_desksiz.height;
}
else if ( rect.bottom_y == old_deskrect.bottom_y )
{
center.y += ( desksiz.height - old_desksiz.height );
pos.y += ( desksiz.height - old_desksiz.height );
}
else if ( rect.top_y != 0 )
{
center.y = ( center.y * desksiz.height ) /
old_desksiz.height;
pos.y = ( pos.y * desksiz.height ) /
old_desksiz.height;
}
Set_Min_Size( siz, siz, Tilwin_Get_Max( winp ) )
Set_Max_Size( siz, siz, Tilwin_Get_Min( winp ) )
Tilwin_Set( winp, center, siz );
Tilwin_Set_Position( winp, pos );
}
if ( UserGlobals_Get_Option(USE_ICONS) )
Manage_Icon_Open( rtl_uwinp );
for ( winp = head; winp != WIN_NULL;
winp = (Tilwinp)Tilwin_Get_Data(winp) )
{
uwinp = Userwin_Get(winp);
if ( uwinp->current_type == body )
Tilwin_Open_Nearest_In_Area( winp, deskrect,
Tilwin_Get_Center( winp ), Tilwin_Get_Size( winp ) );
else if ( UserGlobals_Get_Option(USE_ICONS) )
Manage_Icon_Open( uwinp );
}
if ( UserGlobals_Get_Option(AUTO_REPOP_ON_DESKTOP_RESIZE) )
Manage_Repopulate_Since( (TimeStamp)0, TRUE, FALSE, TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Resize_Desktop( desksiz )
Size desksiz;
{
drawing = TRUE;
Manage_Start();
Manage_Reorganize_Desktop( desksiz );
Drawwin_Draw_Background( Tilwin_Get_Desktop_Rectangle() );
Manage_Finish( TRUE );
drawing = FALSE;
Manage_Cant_Undo();
}
/* ------------------------------------------------------------ */
void Manage_Profile( filnam )
char *filnam;
{
int primary, secondary;
Userwin *uwinp;
Tilwinp winp;
Manage_Start();
secondary = UserGlobals_Get_Value( SECONDARY_ICON_PLACEMENT);
primary = UserGlobals_Get_Value( ICON_PLACEMENT);
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
{
if ( listener != UWIN_NULL )
Tilwin_Set_Window_Option( listener->winp, REQUIRE_MANUAL_CLOSE,
listener->regular_manual_close );
if ( sublistener != UWIN_NULL )
Tilwin_Set_Window_Option( sublistener->winp, REQUIRE_MANUAL_CLOSE,
sublistener->regular_manual_close );
}
Profile_Update( filnam );
Userwin_Set_Window_Option( rtl_uwinp, SHOW_ICON,
UserGlobals_Get_Option(USE_RTL_ICON) );
Manage_Reorganize_Desktop( Tilwin_Get_Desktop_Size() );
Tilwin_Gen_Open_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->iconp == winp )
{
if ( ( secondary !=
UserGlobals_Get_Value(SECONDARY_ICON_PLACEMENT) ) ||
( primary !=
UserGlobals_Get_Value(ICON_PLACEMENT) ) )
Tilwin_Set_Position( winp, Tilwin_Get_Center( winp ) );
}
}
if (! UserGlobals_Get_Option(ALLOW_LISTENER_TO_CLOSE))
{
if ( listener != UWIN_NULL )
Tilwin_Set_Window_Option( listener->winp,
REQUIRE_MANUAL_CLOSE, TRUE );
if ( sublistener != UWIN_NULL )
Tilwin_Set_Window_Option( sublistener->winp,
REQUIRE_MANUAL_CLOSE, TRUE );
}
redrawing = TRUE;
Manage_Finish( TRUE );
redrawing = FALSE;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
#define Manage_Set_Rezoom_Horizontal(uwinp,op) \
{ \
if ( Tilwin_Get_Rectangle(uwinp->winp).left_x == 0 ) \
window_excursion( uwinp->winp, FIXED_LEFT_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).right_x == \
( Tilwin_Get_Desktop_Size().width - 1 ) ) \
window_excursion( uwinp->winp, FIXED_RIGHT_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).left_x == \
uwinp->rezoom_rect.left_x ) \
window_excursion( uwinp->winp, FIXED_LEFT_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).right_x == \
uwinp->rezoom_rect.right_x ) \
window_excursion( uwinp->winp, FIXED_RIGHT_EDGE, TRUE, op ) \
else op; \
}
/* ------------------------------------------------------------ */
#define Manage_Set_Rezoom_Vertical(uwinp,op) \
{ \
if ( Tilwin_Get_Rectangle(uwinp->winp).top_y == 0 ) \
window_excursion( uwinp->winp, FIXED_TOP_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).bottom_y == \
( Tilwin_Get_Desktop_Size().height - 1 ) ) \
window_excursion( uwinp->winp, FIXED_BOTTOM_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).top_y == \
uwinp->rezoom_rect.top_y ) \
window_excursion( uwinp->winp, FIXED_TOP_EDGE, TRUE, op ) \
else if ( Tilwin_Get_Rectangle(uwinp->winp).bottom_y == \
uwinp->rezoom_rect.bottom_y ) \
window_excursion( uwinp->winp, FIXED_BOTTOM_EDGE, TRUE, op ) \
else op; \
}
/* ------------------------------------------------------------ */
static bool Manage_Rezoom( uwinp, siz )
Userwin *uwinp;
Size siz;
{
bool result;
Manage_Set_Rezoom_Vertical( uwinp,
Manage_Set_Rezoom_Horizontal( uwinp,
result = Tilwin_Set_Size( uwinp->winp, siz ) ) );
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Rezoom_In_Area( uwinp, rect, pt, siz )
Userwin *uwinp;
TWRectangle rect;
TWPoint pt;
Size siz;
{
bool result;
Manage_Set_Rezoom_Vertical( uwinp,
Manage_Set_Rezoom_Horizontal( uwinp,
result = Tilwin_Open_Nearest_In_Area(
uwinp->winp, rect, pt, siz ) ) );
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Neighborhood_Rezoom( uwinp, siz )
Userwin *uwinp;
Size siz;
{
TWRectangle rect;
TWPoint pt;
bool result;
pt = Tilwin_Get_Center( uwinp->winp );
rect = Manage_Neighborhood_Rectangle( 0.5, pt, siz );
global_excursion( ALLOW_AUTOMATIC_CLOSE, FALSE,
{ window_excursion( uwinp->winp, FIXED_SIZE, TRUE,
{
result = Manage_Rezoom( uwinp, siz );
if (! result)
result = Manage_Rezoom_In_Area( uwinp, rect, pt, siz );
} ) } );
if (! result)
result = Tilwin_Open_Nearest_In_Area( uwinp->winp, rect, pt, siz );
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Neighborhood_Unzoom_Open( uwinp, siz )
Userwin *uwinp;
Size siz;
{
TWRectangle rect;
TWPoint pt;
bool result;
pt = Tilwin_Get_Center( uwinp->winp );
rect = Tilwin_Get_Rectangle( uwinp->winp );
result = Manage_Rezoom_In_Area( uwinp, rect, pt, siz );
if (! result)
result = Tilwin_Open_Nearest_In_Area(
uwinp->winp, rect, pt, siz );
if ( (! result) &&
(! Userwin_Get_Window_Option(
uwinp, REQUIRE_PREV_POS ) ) )
result = Tilwin_Open_Nearest_In_Area(
uwinp->winp,
Tilwin_Get_Desktop_Rectangle(),
pt, siz );
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static void Manage_Setup_Zoom( uwinp, full )
Userwin *uwinp;
bool full;
{
Size siz;
Manage_Save_State( uwinp );
uwinp->zoomed = TRUE;
uwinp->regular_min = Tilwin_Get_Min(uwinp->winp);
uwinp->regular_size = Tilwin_Get_Desired(uwinp->winp);
if ( full )
{
if ( Userwin_Get_Window_Option( uwinp, ZOOM_FULL_HEIGHT ) )
uwinp->zoom_size.height = Tilwin_Get_Desktop_Size().height;
if ( Userwin_Get_Window_Option( uwinp, ZOOM_FULL_WIDTH ) )
uwinp->zoom_size.width = Tilwin_Get_Desktop_Size().width;
}
if ( UserGlobals_Get_Option( RESET_ZOOM_MIN ) )
{
if ( UserGlobals_Get_Option( RESET_ZOOM_MIN_USES_DESIRE ) )
Set_Min_Size( siz, uwinp->regular_size,
Tilwin_Get_Size( uwinp->winp ) )
else
siz = Tilwin_Get_Size( uwinp->winp );
if ( UserGlobals_Get_Option( RESET_ZOOM_MIN_ALLOWS_DECREASE ) )
uwinp->zoom_min = siz;
else
Set_Max_Size( uwinp->zoom_min, uwinp->zoom_min, siz )
}
if ( Userwin_Get_Window_Option( uwinp, ZOOM_TIED_TO_DESIRE ) )
{
uwinp->zoom_min = uwinp->zoom_size = uwinp->regular_size;
}
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
{
Set_Max_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->client_min )
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->client_min )
}
Set_Max_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->regular_min )
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->regular_size )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
{
Set_Min_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->client_max )
Set_Min_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->client_max )
}
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
/* ------------------------------------------------------------ */
static void Manage_Setup_Unzoom( uwinp )
Userwin *uwinp;
{
Manage_Save_State( uwinp );
uwinp->zoomed = FALSE;
uwinp->zoom_min = Tilwin_Get_Min(uwinp->winp);
uwinp->zoom_size = Tilwin_Get_Desired(uwinp->winp);
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
{
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->client_max )
Set_Min_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->client_max )
}
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->zoom_min )
Set_Min_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->zoom_size )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
{
Set_Max_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->client_min )
Set_Max_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->client_min )
}
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
/* ------------------------------------------------------------ */
static Size Manage_Get_Zoom_Size( uwinp )
Userwin *uwinp;
{
Size cursiz, siz;
cursiz = Tilwin_Get_Size(uwinp->winp);
Set_Max_Size( siz, uwinp->zoom_size, uwinp->zoom_min )
if ( Tilwin_Is_Open( uwinp->winp ) &&
( siz.width < cursiz.width ) &&
( siz.height < cursiz.height ) )
siz = cursiz;
return Tilwin_Checked_Size( uwinp->winp, siz );
}
/* ------------------------------------------------------------ */
static Size Manage_Get_Unzoom_Open_Size( uwinp )
Userwin *uwinp;
{
Size siz;
Set_Max_Size( siz, uwinp->zoom_size, uwinp->regular_min )
return Tilwin_Checked_Size( uwinp->winp, siz );
}
/* ------------------------------------------------------------ */
static Size Manage_Get_Closed_Unzoom_Size( uwinp )
Userwin *uwinp;
{
Size siz;
Set_Max_Size( siz, uwinp->regular_size, uwinp->regular_min )
Set_Min_Size( siz, siz, Tilwin_Get_Size(uwinp->winp) )
return Tilwin_Checked_Size( uwinp->winp, siz );
}
/* ------------------------------------------------------------ */
static Size Manage_Get_Open_Unzoom_Size( uwinp )
Userwin *uwinp;
{
Size siz;
COMPUTE_SIZE( uwinp->rezoom_rect, siz );
Set_Min_Size( siz, siz, uwinp->regular_size )
Set_Min_Size( siz, siz, Tilwin_Get_Size(uwinp->winp) )
Set_Max_Size( siz, siz, uwinp->regular_min )
return Tilwin_Checked_Size( uwinp->winp, siz );
}
/* ------------------------------------------------------------ */
static bool Manage_Followup_Zoom( uwinp )
Userwin *uwinp;
{
Size siz;
bool result;
siz = Manage_Get_Zoom_Size( uwinp );
if ( ( siz.width < uwinp->zoom_min.width ) ||
( siz.height < uwinp->zoom_min.height ) )
result = FALSE;
else
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE,
Userwin_Get_Window_Option( uwinp, ALLOW_ZOOM_CLOSE ),
{
result = Manage_Neighborhood_Rezoom( uwinp, siz );
} )
if ( result )
{
Set_Max_Size( siz, siz,
Tilwin_Get_Previous_Size( uwinp->winp ) );
global_restrict_excursion( ALLOW_AUTOMATIC_SHRINK, FALSE,
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE, FALSE,
Tilwin_Enlarge_Nearest( uwinp->winp,
Tilwin_Get_Previous_Center( uwinp->winp ),
siz ) ) )
Tilwin_Act_Modified( uwinp->winp );
uwinp->zoom_stamp = Tilwin_Get_Timestamp();
uwinp->rezoom_rect = Tilwin_Get_Previous_Rectangle( uwinp->winp );
}
else
Manage_Setup_Unzoom( uwinp );
return result;
}
/* ------------------------------------------------------------ */
static void Manage_Followup_Unzoom( uwinp, explicit )
Userwin *uwinp;
bool explicit;
{
bool force_repop;
bool force_shrink;
bool allow_shrink;
TimeStamp repop_since;
TWPoint pt;
Size siz;
if (! Tilwin_Is_Open( uwinp->winp ) )
Manage_Rezoom( uwinp, Manage_Get_Closed_Unzoom_Size( uwinp ) );
else
{
Tilwin_Act_Modified( uwinp->winp );
if ( explicit )
{
allow_shrink =
Userwin_Get_Window_Option(uwinp,ALLOW_SHRINK_ON_UNZOOM);
force_shrink =
Userwin_Get_Window_Option(uwinp,FORCE_SHRINK_ON_UNZOOM);
force_repop = UserGlobals_Get_Option(
AUTO_REPOP_ON_EXPLICIT_UNZOOM);
if ( UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_EXPL_UNZOOM) )
repop_since = uwinp->zoom_stamp;
else
repop_since = (TimeStamp)0;
}
else
{
allow_shrink =
Userwin_Get_Window_Option(uwinp,ALLOW_SHRINK_ON_UNZOOM) &&
Userwin_Get_Window_Option(uwinp,ALLOW_SHRINK_ON_AUTO_UNZOOM);
force_shrink =
Userwin_Get_Window_Option(uwinp,FORCE_SHRINK_ON_UNZOOM) &&
Userwin_Get_Window_Option(uwinp,FORCE_SHRINK_ON_AUTO_UNZOOM);
force_repop = UserGlobals_Get_Option(
AUTO_REPOPULATE_ON_AUTO_UNZOOM);
if ( UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_AUTO_UNZOOM) )
repop_since = uwinp->zoom_stamp;
else
repop_since = (TimeStamp)0;
}
if ( allow_shrink || force_shrink )
{
COMPUTE_CENTER( uwinp->rezoom_rect, pt );
siz = Manage_Get_Open_Unzoom_Size( uwinp );
global_excursion( ALLOW_AUTOMATIC_CLOSE, FALSE,
{
if ( Tilwin_Set( uwinp->winp, pt, siz ) )
Tilwin_Set_Position( uwinp->winp, pt );
else
Manage_Rezoom( uwinp, siz );
} )
}
if ( force_repop )
{
user_global_excursion(
REQUIRE_PREV_POS_ON_AUTO_REPOP, TRUE,
Manage_Repopulate_Since( repop_since, FALSE, FALSE, TRUE ) );
}
if ( UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
window_excursion( uwinp->winp, FIXED_SIZE, TRUE,
Manage_Ordered_Desire() );
if ( allow_shrink && (! force_shrink) )
global_excursion( ALLOW_AUTOMATIC_SHRINK, FALSE,
global_excursion( ALLOW_AUTOMATIC_CLOSE, FALSE,
{
if ( UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Tilwin_Enlarge_Nearest( uwinp->winp,
Tilwin_Get_Previous_Center( uwinp->winp ),
Tilwin_Get_Previous_Size( uwinp->winp ) );
else
Tilwin_Open_Nearest_In_Area( uwinp->winp,
Tilwin_Get_Previous_Rectangle( uwinp->winp ),
Tilwin_Get_Previous_Center( uwinp->winp ),
Tilwin_Get_Previous_Size( uwinp->winp ) );
} ) )
if ( force_repop )
{
Manage_Repopulate_Since( repop_since,
FALSE, FALSE, TRUE );
}
}
uwinp->rezoom_rect = Tilwin_Get_Previous_Rectangle( uwinp->winp );
}
/* ------------------------------------------------------------ */
static bool Manage_Followup_Unzoom_Open( uwinp )
Userwin *uwinp;
{
bool result;
result = Manage_Neighborhood_Unzoom_Open( uwinp,
Manage_Get_Unzoom_Open_Size( uwinp ) );
if ( result )
uwinp->rezoom_rect = Tilwin_Get_Previous_Rectangle( uwinp->winp );
else
Manage_Setup_Zoom( uwinp, FALSE );
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool Manage_Do_Zoom( uwinp, explicit )
Userwin *uwinp;
bool explicit;
{
bool full;
full =
(
( Userwin_Get_Window_Option(uwinp,ZOOM_FULL_EXPLICIT) &&
explicit )
&&
(
Userwin_Get_Window_Option(uwinp,ZOOM_FULL_WIDTH)
||
Userwin_Get_Window_Option(uwinp,ZOOM_FULL_HEIGHT)
)
);
Manage_Setup_Zoom( uwinp, full );
return Manage_Followup_Zoom( uwinp );
}
/* ------------------------------------------------------------ */
static void Manage_Do_Unzoom( uwinp, explicit )
Userwin *uwinp;
bool explicit;
{
Manage_Setup_Unzoom( uwinp );
Manage_Followup_Unzoom( uwinp, explicit );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static Userwin *unzoomed_listener;
/* ------------------------------------------------------------ */
static void Manage_Start_Trying()
{
unzoomed_listener = UWIN_NULL;
}
/* ------------------------------------------------------------ */
bool Manage_Can_Try_Listener_Unzoom()
{
if ( UserGlobals_Get_Option(UNZOOM_TIED_LSNR_IF_NECESSARY) &&
( listener != UWIN_NULL ) &&
Userwin_Get_Window_Option(listener,LISTENER_TIED_TO_ZOOM) &&
listener->zoomed )
{
Manage_Setup_Unzoom( listener );
unzoomed_listener = listener;
return TRUE;
}
else
return FALSE;
}
/* ------------------------------------------------------------ */
static void Manage_Finish_Trying( result )
bool result;
{
if ( unzoomed_listener != UWIN_NULL )
{
if ( result )
Manage_Followup_Unzoom( unzoomed_listener, FALSE );
else
Manage_Setup_Zoom( unzoomed_listener, FALSE );
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
bool Manage_Unzoom_Open( uwinp )
Userwin *uwinp;
{
bool iconized;
bool result;
iconized = Tilwin_Is_Open( uwinp->iconp );
if ( iconized )
Tilwin_Close( uwinp->iconp );
Manage_Setup_Unzoom( uwinp );
result = Manage_Followup_Unzoom_Open( uwinp );
if ( (! result) && iconized )
Tilwin_Open( uwinp->iconp,
Tilwin_Get_Center( uwinp->iconp ),
Tilwin_Get_Size( uwinp->iconp ) );
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Zoom( uwinp )
Userwin *uwinp;
{
bool result;
Manage_Start();
Manage_Start_Trying();
result = Manage_Do_Zoom( uwinp, TRUE );
if ( (! result) && Manage_Can_Try_Listener_Unzoom() )
result = Manage_Do_Zoom( uwinp, TRUE );
Manage_Finish_Trying( result );
Tilwin_Note_Desired_Width( uwinp->winp );
Tilwin_Note_Desired_Height( uwinp->winp );
last_zoom = uwinp;
touch = uwinp;
Manage_Finish_Minned( uwinp, result );
}
/* ------------------------------------------------------------ */
void Manage_Unzoom( uwinp )
Userwin *uwinp;
{
if ( ( uwinp == last_zoom ) &&
( uwinp->zoom_stamp == last_stamp ) )
Manage_Undo_Start();
else
{
Manage_Start();
Manage_Do_Unzoom( uwinp, TRUE );
}
touch = uwinp;
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Toggle_Zoom( uwinp )
Userwin *uwinp;
{
if ( uwinp->zoomed )
Manage_Unzoom( uwinp );
else
Manage_Zoom( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Toggle_Zoom_Lock( uwinp )
Userwin *uwinp;
{
if ( Userwin_Tied_Listener(uwinp) )
{
Userwin_Dont_Tie_Listener( uwinp );
Manage_Start();
Tilwin_Act_Modified( uwinp->winp );
touch = uwinp;
Manage_Finish( TRUE );
}
else
{
Userwin_Allow_Tie_Listener( uwinp );
if ( ( uwinp == listener ) && (! uwinp->zoomed) )
Manage_Zoom( uwinp );
else if ( ( uwinp != listener ) && ( uwinp->zoomed ) )
Manage_Unzoom( uwinp );
else
{
Manage_Start();
Tilwin_Act_Modified( uwinp->winp );
touch = uwinp;
Manage_Finish( TRUE );
}
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Switch_Listener( uwinp )
Userwin *uwinp;
{
Userwin *old_listener;
bool unzoom_old;
bool zoom_new;
bool listener_zooming;
bool transact;
TimeStamp zoom_stamp = (TimeStamp)0;
switch_listener = uwinp;
unzoom_old = (listener != UWIN_NULL) && (listener->zoomed) &&
Userwin_Get_Window_Option(listener,LISTENER_TIED_TO_ZOOM);
zoom_new = (uwinp != UWIN_NULL) && (!uwinp->zoomed) &&
Userwin_Get_Window_Option(uwinp,LISTENER_TIED_TO_ZOOM);
listener_zooming = unzoom_old || zoom_new;
transact = listener_zooming ||
( UserGlobals_Get_Option(AUTO_PRORATE) &&
UserGlobals_Get_Option(BIASED_AUTO_PRORATE) );
old_listener = listener;
if ( unzoom_old )
zoom_stamp = listener->zoom_stamp;
if ( unzoom_old &&
UserGlobals_Get_Option(AUTO_REPOPULATE_ON_AUTO_UNZOOM) &&
( listener == last_zoom ) &&
( zoom_stamp == last_stamp ) )
{
Manage_Undo_Start();
unzoom_old = FALSE;
if ( zoom_new )
last_zoom = UWIN_NULL;
}
else if ( listener_zooming )
{
Manage_Start();
if (! unzoom_old)
last_zoom = uwinp;
}
else if ( transact )
Manage_Start();
if ( listener != UWIN_NULL )
{
Manage_Unset_Listener();
if ( unzoom_old )
Manage_Setup_Unzoom( old_listener );
else if (! transact)
Drawwin_Display_Wrapping( old_listener );
}
Manage_Set_Listener(uwinp);
if ( listener != UWIN_NULL )
{
if ( zoom_new )
{
if ( Manage_Do_Zoom( listener, FALSE ) &&
( zoom_stamp != (TimeStamp)0 ) )
listener->zoom_stamp = zoom_stamp;
}
else if (! transact)
Drawwin_Display_Wrapping( listener );
}
if ( unzoom_old )
{
if ( listener == UWIN_NULL )
Manage_Followup_Unzoom( old_listener, FALSE );
else
min_excursion( listener->winp,
Manage_Followup_Unzoom( old_listener, FALSE ) )
}
if ( transact )
Manage_Finish_Minned( listener, TRUE );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool Manage_Resatisfy( uwinp )
Userwin *uwinp;
{
bool result;
Size siz;
Manage_Save_State( uwinp );
result = Tilwin_Is_Satisfied( uwinp->winp );
if (! result )
{
siz = Tilwin_Get_Size( uwinp->winp );
Set_Max_Size( siz, siz, Tilwin_Get_Min( uwinp->winp ) )
Set_Min_Size( siz, siz, Tilwin_Get_Max( uwinp->winp ) )
if ( Tilwin_Is_Open(uwinp->winp) )
result = Manage_Neighborhood_Rezoom( uwinp, siz );
else
result = Manage_Rezoom( uwinp, siz );
}
return result;
}
/* ------------------------------------------------------------ */
void Manage_Client_Reset_Min_Max( uwinp, min_size, max_size )
Userwin *uwinp;
Size min_size;
Size max_size;
{
Size siz;
bool has_min, has_max, result;
if (! uwinp->prepared)
Manage_Prepare( uwinp );
has_max = ( max_size.width > 0 ) && ( max_size.height > 0 );
has_min = ( min_size.width >= 0 ) && ( min_size.height >= 0 );
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MAX_WIDTH ) )
max_size.width = uwinp->body_max.width;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MAX_HEIGHT ) )
max_size.height = uwinp->body_max.height;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MIN_WIDTH ) )
min_size.width = uwinp->body_min.width;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MIN_HEIGHT ) )
min_size.height = uwinp->body_min.height;
if ( has_min )
Set_Max_Size( max_size, max_size, min_size )
if ( has_max )
{
uwinp->body_max = max_size;
uwinp->client_max = Region_Adjust_Size( uwinp, max_size );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
{
Set_Min_Size( siz, Tilwin_Get_Max( uwinp->winp ),
uwinp->client_max )
Tilwin_Set_Max( uwinp->winp, siz );
Set_Min_Size( siz, siz, Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, siz );
}
}
if ( has_min )
{
uwinp->body_min = min_size;
uwinp->client_min = Region_Adjust_Size( uwinp, min_size );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
{
Set_Max_Size( siz, Tilwin_Get_Min( uwinp->winp ),
uwinp->client_min )
Tilwin_Set_Min( uwinp->winp, siz );
Set_Max_Size( siz, siz, Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, siz );
}
}
if ( Same_Size( Tilwin_Get_Min(uwinp->winp),
Tilwin_Get_Max(uwinp->winp) ) )
uwinp->sized = TRUE;
if (! uwinp->ever_opened)
return;
if (! Tilwin_Is_Open( uwinp->winp ))
Manage_Resatisfy( uwinp );
else if ( Userwin_Get_Window_Option( uwinp, AUTO_RESATISFY_ON_RESET_MINMAX ) )
{
Manage_Start();
Manage_Client(
{
result = Manage_Resatisfy( uwinp );
} )
Manage_Finish_Minned( uwinp, result );
Manage_Cant_Undo();
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static Size Manage_Calc_Size( siz, rect, side, pos )
Size siz;
TWRectangle rect;
Side side;
TWPoint pos;
{
switch (side)
{
case Top:
case Top_Left:
case Top_Right:
siz.height = 1 + rect.bottom_y - pos.y;
break;
case Bottom:
case Bottom_Left:
case Bottom_Right:
siz.height = 1 + pos.y - rect.top_y;
break;
default:
break;
}
switch (side)
{
case Left:
case Top_Left:
case Bottom_Left:
siz.width = 1 + rect.right_x - pos.x;
break;
case Right:
case Top_Right:
case Bottom_Right:
siz.width = 1 + pos.x - rect.left_x;
break;
default:
break;
}
return siz;
}
/* ------------------------------------------------------------ */
bool Manage_Set_Regular_Min_Size( uwinp, pos, side, force, ctrl )
Userwin *uwinp;
TWPoint pos;
Side side;
bool force, ctrl;
{
Size max_size;
TWRectangle rect;
rect = Tilwin_Get_Rectangle( uwinp->winp );
Manage_Start();
if (! uwinp->zoomed)
uwinp->regular_min = Tilwin_Get_Min( uwinp->winp );
uwinp->regular_min =
Manage_Calc_Size( uwinp->regular_min, rect, side, pos );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->client_max )
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
Tilwin_Get_Max( uwinp->winp ) )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->client_min )
max_size = Tilwin_Get_Max( uwinp->winp );
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force )
Set_Max_Size( max_size, max_size, uwinp->regular_min )
else
Set_Min_Size( uwinp->regular_min, uwinp->regular_min, max_size )
Tilwin_Set_Max( uwinp->winp, max_size );
if (! uwinp->zoomed)
{
Set_Max_Size( uwinp->regular_size, uwinp->regular_min,
Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
else
{
Set_Max_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->regular_min )
Set_Max_Size( uwinp->zoom_min, uwinp->regular_min,
Tilwin_Get_Min( uwinp->winp ) )
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_min,
Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
Manage_Resatisfy( uwinp );
Manage_Finish( TRUE );
return TRUE;
}
/* ------------------------------------------------------------ */
bool Manage_Set_Zoom_Min_Size( uwinp, pos, side, force, ctrl )
Userwin *uwinp;
TWPoint pos;
Side side;
bool force, ctrl;
{
Size max_size;
TWRectangle rect;
rect = Tilwin_Get_Rectangle( uwinp->winp );
Manage_Start();
if ( uwinp->zoomed )
uwinp->zoom_min = Tilwin_Get_Min( uwinp->winp );
uwinp->zoom_min =
Manage_Calc_Size( uwinp->zoom_min, rect, side, pos );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->client_max )
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
Tilwin_Get_Max( uwinp->winp ) )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->client_min )
max_size = Tilwin_Get_Max( uwinp->winp );
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force )
Set_Max_Size( max_size, max_size, uwinp->zoom_min )
else
Set_Min_Size( uwinp->zoom_min, uwinp->zoom_min, max_size )
Tilwin_Set_Max( uwinp->winp, max_size );
if ( uwinp->zoomed )
{
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_min,
Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
else
{
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->zoom_min )
Set_Min_Size( uwinp->regular_min, uwinp->zoom_min,
Tilwin_Get_Min( uwinp->winp ) )
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
}
Manage_Resatisfy( uwinp );
Manage_Finish( TRUE );
return TRUE;
}
/* ------------------------------------------------------------ */
bool Manage_Set_Regular_Desired_Size( uwinp, pos, side, force, ctrl )
Userwin *uwinp;
TWPoint pos;
Side side;
bool force, ctrl;
{
Size max_size;
TWRectangle rect;
rect = Tilwin_Get_Rectangle( uwinp->winp );
Manage_Start();
if (! uwinp->zoomed )
{
uwinp->regular_size = Tilwin_Get_Desired( uwinp->winp );
uwinp->regular_min = Tilwin_Get_Min( uwinp->winp );
}
else
uwinp->zoom_min = Tilwin_Get_Min( uwinp->winp );
uwinp->regular_size =
Manage_Calc_Size( uwinp->regular_size, rect, side, pos );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->client_max )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->client_min )
max_size = Tilwin_Get_Max( uwinp->winp );
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force )
Set_Max_Size( max_size, max_size, uwinp->regular_size )
else
Set_Min_Size( uwinp->regular_size, uwinp->regular_size, max_size )
Tilwin_Set_Max( uwinp->winp, max_size );
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force )
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->regular_size )
else
Set_Max_Size( uwinp->regular_size, uwinp->regular_size,
uwinp->regular_min )
if (! uwinp->zoomed)
{
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
else
{
Set_Max_Size( uwinp->zoom_size, uwinp->regular_size,
Tilwin_Get_Size( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
Manage_Finish( TRUE );
return TRUE;
}
/* ------------------------------------------------------------ */
bool Manage_Set_Zoom_Desired_Size( uwinp, pos, side, force, ctrl )
Userwin *uwinp;
TWPoint pos;
Side side;
bool force, ctrl;
{
Size max_size;
TWRectangle rect;
rect = Tilwin_Get_Rectangle( uwinp->winp );
Manage_Start();
if ( uwinp->zoomed )
{
uwinp->zoom_size = Tilwin_Get_Desired( uwinp->winp );
uwinp->zoom_min = Tilwin_Get_Min( uwinp->winp );
}
else
uwinp->regular_min = Tilwin_Get_Min( uwinp->winp );
uwinp->zoom_size =
Manage_Calc_Size( uwinp->zoom_size, rect, side, pos );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->client_max )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->client_min )
max_size = Tilwin_Get_Max( uwinp->winp );
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force )
Set_Max_Size( max_size, max_size, uwinp->zoom_size )
else
Set_Min_Size( uwinp->zoom_size, uwinp->zoom_size, max_size )
Tilwin_Set_Max( uwinp->winp, max_size );
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force )
Set_Min_Size( uwinp->zoom_min, uwinp->zoom_min,
uwinp->zoom_size )
else
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->zoom_min )
if (uwinp->zoomed)
{
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
else
{
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force )
{
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
uwinp->zoom_size )
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
}
else
{
Set_Max_Size( uwinp->zoom_size, uwinp->zoom_size,
uwinp->regular_min )
}
Set_Min_Size( uwinp->regular_size, uwinp->zoom_size,
Tilwin_Get_Size( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
Manage_Finish( TRUE );
return TRUE;
}
/* ------------------------------------------------------------ */
bool Manage_Set_Max_Size( uwinp, pos, side, force, ctrl )
Userwin *uwinp;
TWPoint pos;
Side side;
bool force, ctrl;
{
Size max_size;
TWRectangle rect;
rect = Tilwin_Get_Rectangle( uwinp->winp );
Manage_Start();
max_size = Manage_Calc_Size(
Tilwin_Get_Max( uwinp->winp), rect, side, pos );
if (uwinp->zoomed)
uwinp->zoom_min = Tilwin_Get_Min( uwinp->winp );
else
uwinp->regular_min = Tilwin_Get_Min( uwinp->winp );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( max_size, max_size, uwinp->client_max )
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( max_size, max_size, uwinp->client_min )
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force )
{
Set_Min_Size( uwinp->regular_min, uwinp->regular_min,
max_size )
Set_Min_Size( uwinp->zoom_min, uwinp->zoom_min,
max_size )
}
else
{
Set_Max_Size( max_size, max_size, uwinp->regular_min )
Set_Max_Size( max_size, max_size, uwinp->zoom_min )
}
Tilwin_Set_Max( uwinp->winp, max_size );
if ( uwinp->zoomed )
{
Set_Min_Size( uwinp->zoom_size, max_size,
Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
Set_Min_Size( uwinp->regular_size, uwinp->regular_size, max_size )
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
}
else
{
Set_Min_Size( uwinp->regular_size, max_size,
Tilwin_Get_Desired( uwinp->winp ) )
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
Set_Min_Size( uwinp->zoom_size, uwinp->zoom_size, max_size )
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
}
Manage_Resatisfy( uwinp );
Manage_Finish( TRUE );
return TRUE;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Min_Max_Resizing( uwinp, siz1, siz2 )
Userwin *uwinp;
Size siz1, siz2;
{
Size siz;
Set_Min_Size( siz, siz1, siz2 )
Tilwin_Set_Min( uwinp->winp, siz );
Set_Max_Size( siz, siz1, siz2 )
Tilwin_Set_Max( uwinp->winp, siz );
}
/* ------------------------------------------------------------ */
void Manage_Cancel_Resizing( uwinp )
Userwin *uwinp;
{
Tilwin_Set_Min( uwinp->winp, uwinp->prev_min );
Tilwin_Set_Max( uwinp->winp, uwinp->prev_max );
}
/* ------------------------------------------------------------ */
void Manage_Finish_Resizing( uwinp, side, force, undesire )
Userwin *uwinp;
Side side;
bool force, undesire;
{
Size newmin, newmax;
Size siz, prevsiz, desired;
bool horiz, vert, enlarge;
horiz = ( side != NoSide ) && ( side != Top ) && ( side != Bottom );
vert = ( side != NoSide ) && ( side != Left ) && ( side != Right );
newmin = uwinp->prev_min;
newmax = uwinp->prev_max;
if ( uwinp->sized )
prevsiz = Tilwin_Get_Previous_Size( uwinp->winp );
else
{
prevsiz = newmin;
if ( UserGlobals_Get_Option(RESET_MIN_MAX_ON_UNSZD_MAN_OPEN) )
{
force = TRUE;
horiz = TRUE;
vert = TRUE;
}
}
siz = Tilwin_Get_Size( uwinp->winp );
if (! undesire)
{
desired = Tilwin_Get_Desired( uwinp->winp );
enlarge = (desired.width > prevsiz.width) ||
(desired.height > prevsiz.height);
if ( horiz )
{
if ( desired.width >= prevsiz.width )
{
if ( force || UserGlobals_Get_Option(RESET_MIN_ON_ENLARGE) ||
( UserGlobals_Get_Option(RESET_TIED_ZOOMED_MIN_ON_ENLARGE) &&
(uwinp->zoomed) &&
Userwin_Get_Window_Option(uwinp,LISTENER_TIED_TO_ZOOM) ) )
newmin.width = siz.width;
}
else
{
if ( (! enlarge) &&
( force || UserGlobals_Get_Option(RESET_MAX_ON_SHRINK) ) )
newmax.width = siz.width;
}
}
if ( vert )
{
if ( desired.height >= prevsiz.height )
{
if ( force || UserGlobals_Get_Option(RESET_MIN_ON_ENLARGE) ||
( UserGlobals_Get_Option(
RESET_TIED_ZOOMED_MIN_ON_ENLARGE) &&
(uwinp->zoomed) &&
Userwin_Get_Window_Option(uwinp,LISTENER_TIED_TO_ZOOM) ) )
newmin.height = siz.height;
}
else
{
if ( (! enlarge) &&
( force || UserGlobals_Get_Option(RESET_MAX_ON_SHRINK) ) )
newmax.height = siz.height;
}
}
}
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force )
Set_Min_Size( newmin, newmin, siz )
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force )
Set_Max_Size( newmax, newmax, siz )
Tilwin_Set_Min( uwinp->winp, newmin );
Tilwin_Set_Max( uwinp->winp, newmax );
Set_Min_Size( siz, newmax, Tilwin_Get_Desired(uwinp->winp) )
Set_Max_Size( siz, newmin, siz )
Tilwin_Set_Desired( uwinp->winp, siz );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool Manage_Slide_Resize( uwinp, center, siz, side )
Userwin *uwinp;
TWPoint center;
Size siz;
Side side;
{
bool result;
Size shrinksiz;
Side shrinkside = NoSide;
if (! UserGlobals_Get_Option(TRY_SLIDING_ON_RESIZE))
return Tilwin_Resize( uwinp->winp, siz, side );
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE,
(! UserGlobals_Get_Option(
PREF_SLD_TO_AUTO_CL_ON_RESIZE)),
{ global_restrict_excursion( ALLOW_AUTOMATIC_SHRINK,
(! UserGlobals_Get_Option(
PREF_SLD_TO_AUTO_SHR_ON_RESIZE)),
{ window_join_excursion( uwinp->winp, FIXED_SIZE,
UserGlobals_Get_Option(PREF_SLD_TO_SHRINK_ON_RESIZE),
{
result = Tilwin_Resize( uwinp->winp, siz, side );
} ) } ) } );
if ( result ) return TRUE;
shrinksiz = Tilwin_Get_Size( uwinp->winp );
switch (side)
{
case Top:
case Top_Left:
case Top_Right:
if ( siz.height < shrinksiz.height )
{
shrinkside = Top;
shrinksiz.height = siz.height;
}
break;
case Bottom:
case Bottom_Left:
case Bottom_Right:
if ( siz.height < shrinksiz.height )
{
shrinkside = Bottom;
shrinksiz.height = siz.height;
}
break;
default:
break;
}
switch (side)
{
case Left:
case Top_Left:
case Bottom_Left:
if ( siz.width < shrinksiz.width )
{
shrinkside = Left;
shrinksiz.width = siz.width;
}
break;
case Right:
case Top_Right:
case Bottom_Right:
if ( siz.width < shrinksiz.width )
{
shrinkside = Right;
shrinksiz.width = siz.width;
}
break;
default:
break;
}
if ( shrinkside != NoSide )
Tilwin_Resize( uwinp->winp, shrinksiz, shrinkside );
return Tilwin_Enlarge_Nearest( uwinp->winp, center, siz );
}
/* ------------------------------------------------------------ */
static bool Manage_Cntr_Neighborhood_Rsz( uwinp, center, siz, side )
Userwin *uwinp;
TWPoint center;
Size siz;
Side side;
{
bool result;
TWRectangle rect;
if (! UserGlobals_Get_Option(TRY_CTR_NBRHD_ON_RESIZE))
return Manage_Slide_Resize( uwinp, center, siz, side );
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE,
(! UserGlobals_Get_Option(
PF_CTR_NBR_2_AUTO_CL_ON_RESIZE) ),
{ global_restrict_excursion( ALLOW_AUTOMATIC_SHRINK,
(! UserGlobals_Get_Option(
PF_CTR_NBR_2_AUTO_SHR_ON_RESIZE) ),
{ window_join_excursion( uwinp->winp, FIXED_SIZE,
UserGlobals_Get_Option(
PF_CTR_NBR_2_SHRINK_ON_RESIZE),
{
result = Manage_Slide_Resize( uwinp, center, siz, side );
} ) } ) } );
if ( result ) return TRUE;
rect = Manage_Neighborhood_Rectangle( 0.5, center, siz );
return Tilwin_Open_Nearest_In_Area( uwinp->winp, rect, center, siz );
}
/* ------------------------------------------------------------ */
static bool Manage_Edge_Neighborhood_Resize( uwinp, center, siz, side )
Userwin *uwinp;
TWPoint center;
Size siz;
Side side;
{
bool result;
TWRectangle rect;
if (! UserGlobals_Get_Option(TRY_EDGE_NEIGHBORHOOD_ON_RESIZE))
return Manage_Cntr_Neighborhood_Rsz( uwinp, center, siz, side );
global_restrict_excursion( ALLOW_AUTOMATIC_CLOSE,
(! UserGlobals_Get_Option(
PF_EDGE_NBR_2_AUTO_CL_ON_RESIZE) ),
{ global_restrict_excursion( ALLOW_AUTOMATIC_SHRINK,
(! UserGlobals_Get_Option(
PF_EDGE_NBR_2_AUTO_SHR_ON_RESIZE) ),
{ window_join_excursion( uwinp->winp, FIXED_SIZE,
UserGlobals_Get_Option(PF_EDGE_NBR_2_SHRINK_ON_RESIZE),
{
result = Manage_Cntr_Neighborhood_Rsz( uwinp, center, siz, side );
} ) } ) } );
if ( result ) return TRUE;
rect = Manage_Neighborhood_Rectangle( 1.0, center, siz );
return Tilwin_Open_Nearest_In_Area( uwinp->winp, rect, center, siz );
}
/* ------------------------------------------------------------ */
bool Manage_Resize( uwinp, pos, side, force, undesire )
Userwin *uwinp;
Side side;
TWPoint pos;
bool force, undesire;
{
Size siz, desired;
TWPoint center;
TWRectangle rect;
bool result;
siz = Tilwin_Get_Size( uwinp->winp );
rect = Tilwin_Get_Rectangle( uwinp->winp );
siz = Manage_Calc_Size( siz, rect, side, pos );
if (! ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) || force ))
Set_Max_Size( siz, siz, uwinp->prev_min )
if (! ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) || force ))
Set_Min_Size( siz, siz, uwinp->prev_max )
desired = Tilwin_Get_Desired( uwinp->winp );
switch (side)
{
case Top:
case Top_Left:
case Top_Right:
rect.top_y = rect.bottom_y - siz.height + 1;
desired.height = siz.height;
break;
case Bottom:
case Bottom_Left:
case Bottom_Right:
rect.bottom_y = rect.top_y + siz.height - 1;
desired.height = siz.height;
break;
default:
break;
}
switch (side)
{
case Left:
case Top_Left:
case Bottom_Left:
rect.left_x = rect.right_x - siz.width + 1;
desired.width = siz.width;
break;
case Right:
case Top_Right:
case Bottom_Right:
rect.right_x = rect.left_x + siz.width - 1;
desired.width = siz.width;
break;
default:
break;
}
COMPUTE_CENTER( rect, center );
switch (side)
{
case Top:
case Bottom:
center.x = Tilwin_Get_Position(uwinp->winp).x;
break;
case Left:
case Right:
center.y = Tilwin_Get_Position(uwinp->winp).y;
break;
default:
break;
}
Manage_Start();
Manage_Save_State( uwinp );
if (! undesire)
{
Tilwin_Set_Desired( uwinp->winp, desired );
if ( ( side != Top ) && ( side != Bottom ) )
Tilwin_Note_Desired_Width( uwinp->winp );
if ( ( side != Left ) && ( side != Right ) )
Tilwin_Note_Desired_Height( uwinp->winp );
Tilwin_Set_Position( uwinp->winp, center );
uwinp->positioned = TRUE;
}
Manage_Min_Max_Resizing( uwinp, siz, Tilwin_Get_Size( uwinp->winp ) );
Manage_Start_Trying();
global_excursion( PREFER_CLOSE_TO_SHRINK,
UserGlobals_Get_Option(PREFER_CL_TO_SHR_ON_RESIZE),
{ window_join_excursion( uwinp->winp, FIXED_SIZE,
! UserGlobals_Get_Option(ALLOW_SHRINK_ON_RESIZE),
{
result = Same_Size( Tilwin_Get_Size( uwinp->winp ), siz ) ||
( Manage_Edge_Neighborhood_Resize( uwinp, center, siz, side )
&& Tilwin_Was_Just_Modified( uwinp->winp ) );
if ( (! result) &&
( listener != uwinp ) &&
Manage_Can_Try_Listener_Unzoom() )
result = Manage_Edge_Neighborhood_Resize( uwinp, center, siz, side )
&& Tilwin_Was_Just_Modified( uwinp->winp );
} ) } )
Manage_Finish_Trying( result );
if ( result )
Manage_Finish_Resizing( uwinp, side, force, undesire );
else
Manage_Cancel_Resizing( uwinp );
height_excursion( uwinp->winp,
width_excursion( uwinp->winp,
window_excursion( uwinp->winp, REQUIRE_MANUAL_CLOSE, TRUE,
Manage_Finish( result ) ) ) );
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool zoom_forced;
/* ------------------------------------------------------------ */
void Manage_Start_Open( uwinp, force_zoom )
Userwin *uwinp;
bool force_zoom;
{
Manage_Start();
Manage_Start_Trying();
Manage_Save_State( uwinp );
zoom_forced = FALSE;
if (! Tilwin_Is_Open( uwinp->winp ))
{
if ( Tilwin_Is_Open( uwinp->iconp ) )
Tilwin_Close( uwinp->iconp );
if ( Userwin_Get_Window_Option( uwinp, ZOOM_ON_OPEN ) ||
( (! uwinp->ever_opened ) &&
UserGlobals_Get_Option(ZOOM_ON_CREATE) ) )
force_zoom = TRUE;
if ( force_zoom && (! uwinp->zoomed) )
{
zoom_forced = TRUE;
Manage_Do_Zoom( uwinp, FALSE );
}
}
}
/* ------------------------------------------------------------ */
bool Manage_Can_Try_Self_Unzoom( uwinp )
Userwin *uwinp;
{
bool result;
result = UserGlobals_Get_Option(PREFER_UNZOOM_TO_CLOSE)
&& (uwinp->zoomed)
&& (! Tilwin_Is_Open( uwinp->winp ) );
if ( result )
{
zoom_forced = FALSE;
Manage_Do_Unzoom( uwinp, FALSE );
}
return result;
}
/* ------------------------------------------------------------ */
bool Manage_Finish_Unsized_Open( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result )
{
uwinp->open_stamp = Tilwin_Get_Timestamp();
uwinp->ever_opened = TRUE;
}
else if ( zoom_forced )
Manage_Do_Unzoom( uwinp, FALSE );
Manage_Finish_Trying( result );
return Manage_Finish_Locked( uwinp, result );
}
/* ------------------------------------------------------------ */
bool Manage_Finish_Sized_Open( uwinp, result )
Userwin *uwinp;
bool result;
{
if ( result )
{
uwinp->open_stamp = Tilwin_Get_Timestamp();
uwinp->ever_opened = TRUE;
}
else if ( zoom_forced )
Manage_Do_Unzoom( uwinp, FALSE );
Manage_Finish_Trying( result );
return Manage_Finish_Minned( uwinp, result );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
bool Manage_Move( uwinp, pos )
Userwin *uwinp;
TWPoint pos;
{
bool result;
Manage_Start();
Tilwin_Set_Position( uwinp->winp, pos );
uwinp->positioned = TRUE;
if ( (! uwinp->ever_opened ) ||
UserGlobals_Get_Option(TREAT_MOVE_LIKE_RELOCATE) )
{
uwinp->ever_opened = TRUE;
return Manage_Finish_Minned( uwinp,
Manage_Center_Open( uwinp, pos ) );
}
else
{
Manage_Start_Trying();
result = Tilwin_Open( uwinp->winp, pos,
Tilwin_Get_Size( uwinp->winp ) );
if ( (! result) && ( listener != uwinp )
&& Manage_Can_Try_Listener_Unzoom() )
result = Tilwin_Open( uwinp->winp, pos,
Tilwin_Get_Size( uwinp->winp ) );
Manage_Finish_Trying( result );
return Manage_Finish_Fixed_Completely( uwinp, result );
}
}
/* ------------------------------------------------------------ */
bool Manage_Icon_Move( uwinp, pos )
Userwin *uwinp;
TWPoint pos;
{
bool result;
Manage_Start();
Tilwin_Set_Position( uwinp->iconp, pos );
if ( UserGlobals_Get_Option(TREAT_MOVE_LIKE_RELOCATE) )
result = Manage_Neighborhood_Icon_Open( uwinp, pos );
else
{
Manage_Start_Trying();
result = Tilwin_Open( uwinp->iconp, pos,
Tilwin_Get_Size( uwinp->iconp ) );
if ( (! result) && Manage_Can_Try_Listener_Unzoom() )
result = Tilwin_Open( uwinp->iconp, pos,
Tilwin_Get_Size( uwinp->iconp ) );
Manage_Finish_Trying( result );
}
if ( result )
window_excursion( uwinp->iconp, FIXED_COMPLETELY, TRUE,
Manage_Finish( result ) )
else
Manage_Finish( FALSE );
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
#define Configure_Has_X(flags) \
( ( (flags) & (1L << 0) ) != 0 )
#define Configure_Has_Y(flags) \
( ( (flags) & (1L << 1) ) != 0 )
#define Configure_Has_Width(flags) \
( ( (flags) & (1L << 2) ) != 0 )
#define Configure_Has_Height(flags) \
( ( (flags) & (1L << 3) ) != 0 )
#define Configure_Has_Position(flags) \
( Configure_Has_X(flags) || Configure_Has_Y(flags) )
#define Configure_Has_Size(flags) \
( Configure_Has_Width(flags) || Configure_Has_Height(flags) )
/* ------------------------------------------------------------ */
static void Manage_User_Open_Configure( uwinp, pos, siz,
pos_act, siz_act )
Userwin *uwinp;
TWPoint pos;
Size siz;
bool pos_act, siz_act;
{
bool result = TRUE;
if ( pos_act && siz_act )
{
result = Manage_Center_Neighborhood_Open( uwinp, pos, siz );
}
else if ( pos_act )
{
result = Manage_Center_Neighborhood_Open( uwinp, pos,
Tilwin_Get_Desired( uwinp->winp ) );
}
else if ( siz_act )
{
result = Manage_Center_Neighborhood_Open( uwinp,
Tilwin_Get_Center( uwinp->winp ), siz );
}
if (! result)
Draw_Flash();
}
/* ------------------------------------------------------------ */
void Manage_Client_Configure( uwinp, flags, top_left, bodsiz, detail )
Userwin *uwinp;
unsigned long flags;
TWPoint top_left;
Size bodsiz;
int detail;
{
TWPoint center;
Size tempsiz, siz, desired;
TWRectangle rect;
Manage_Start();
rect = Region_Body_Rectangle( uwinp );
COMPUTE_SIZE( rect, tempsiz );
if ( Configure_Has_Width(flags) )
tempsiz.width = bodsiz.width;
if ( Configure_Has_Height(flags) )
tempsiz.height = bodsiz.height;
if ( Configure_Has_X(flags) )
rect.left_x = top_left.x;
if ( Configure_Has_Y(flags) )
rect.top_y = top_left.y;
rect.right_x = rect.left_x + tempsiz.width - 1;
rect.bottom_y = rect.top_y + tempsiz.height - 1;
rect = Region_Adjust_Rectangle( uwinp, rect );
COMPUTE_CENTER( rect, center );
COMPUTE_SIZE( rect, siz );
if ( Configure_Has_Size(flags) )
uwinp->sized = TRUE;
if ( Configure_Has_Position(flags) )
{
uwinp->positioned = TRUE;
Tilwin_Set_Position( uwinp->winp, center );
}
if ( Userwin_Get_Window_Option( uwinp,
ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( siz, siz, uwinp->client_min );
if ( Userwin_Get_Window_Option( uwinp,
ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( siz, siz, uwinp->client_max );
Set_Min_Size( tempsiz,
Tilwin_Get_Min( uwinp->winp ), siz );
Tilwin_Set_Min( uwinp->winp, tempsiz );
Set_Max_Size( tempsiz,
Tilwin_Get_Max( uwinp->winp ), siz );
Tilwin_Set_Max( uwinp->winp, tempsiz );
desired = Tilwin_Get_Desired( uwinp->winp );
if ( Configure_Has_Width(flags) )
desired.width = siz.width;
if ( Configure_Has_Height(flags) )
desired.height = siz.height;
Tilwin_Set_Desired( uwinp->winp, desired );
if (! Tilwin_Was_Actually_Modified( uwinp->winp ))
Client_Configure_Denied( uwinp );
if (! Tilwin_Is_Open( uwinp->winp ) )
{
Tilwin_Set( uwinp->winp, center, siz );
Manage_Finish_Minned( uwinp, TRUE );
Manage_Cant_Undo();
}
else
{
Manage_User_Open_Configure( uwinp, center, siz,
Configure_Has_Position(flags),
Configure_Has_Size(flags) );
Manage_Finish_Minned( uwinp, TRUE );
}
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Icon_Size( uwinp, siz )
Userwin *uwinp;
Size siz;
{
Tilwin_Set_Min( uwinp->iconp, siz );
Tilwin_Set_Max( uwinp->iconp, siz );
Tilwin_Set_Desired( uwinp->iconp, siz );
if ( Tilwin_Is_Open( uwinp->iconp ) )
{
Manage_Client(
{
Manage_Start();
Tilwin_Set_Size( uwinp->iconp, siz );
Manage_Finish( TRUE );
} )
Manage_Cant_Undo();
}
else
Tilwin_Set_Size( uwinp->iconp, siz );
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Icon_Position( uwinp, pt )
Userwin *uwinp;
TWPoint pt;
{
uwinp->icon_positioned = TRUE;
Tilwin_Set_Position( uwinp->iconp, pt );
if ( Tilwin_Is_Open( uwinp->iconp ) )
{
Manage_Client(
{
Manage_Start();
Manage_Icon_Open( uwinp );
Manage_Finish( TRUE );
} )
Manage_Cant_Undo();
}
else
Tilwin_Set( uwinp->iconp, pt, Tilwin_Get_Size( uwinp->iconp ) );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
#define Size_Hints_User_Position(flags) \
( ( (flags) & (1L << 0) ) != 0 )
#define Size_Hints_User_Size(flags) \
( ( (flags) & (1L << 1) ) != 0 )
#define Size_Hints_Client_Position(flags) \
( ( (flags) & (1L << 2) ) != 0 )
#define Size_Hints_Client_Size(flags) \
( ( (flags) & (1L << 3) ) != 0 )
#define Size_Hints_Position(flags) \
( ( (flags) & ((1L << 2) | (1L << 0)) ) != 0 )
#define Size_Hints_Size(flags) \
( ( (flags) & ((1L << 3) | (1L << 1)) ) != 0 )
#define Size_Hints_Min(flags) \
( ( (flags) & (1L << 4) ) != 0 )
#define Size_Hints_Max(flags) \
( ( (flags) & (1L << 5) ) != 0 )
#define Size_Hints_Base(flags) \
( ( (flags) & (1L << 8) ) != 0 )
#define Manage_Use_Size(uwinp,flags) \
( Size_Hints_Size(flags) && \
(! Userwin_Get_Window_Option( uwinp, IGNORE_SIZE_HINTS ) ) && \
( uwinp->ever_opened || \
(! Userwin_Get_Window_Option( uwinp, \
IGNORE_INITIAL_SIZE_HINTS ) ) ) )
#define Manage_Use_Position(uwinp,flags) \
( Size_Hints_Position(flags) && \
(! Userwin_Get_Window_Option( uwinp, IGNORE_POSITION_HINTS ) ) && \
( uwinp->ever_opened || \
(! Userwin_Get_Window_Option( uwinp, \
IGNORE_INITIAL_POSITION_HINTS ) ) ) )
/* ------------------------------------------------------------ */
static void Manage_Act_Hints_Open( uwinp, pos, siz, pos_act, siz_act )
Userwin *uwinp;
TWPoint pos;
Size siz;
bool pos_act, siz_act;
{
bool result;
if ( pos_act )
result = Manage_Center_Neighborhood_Open(
uwinp, pos, siz );
else if ( siz_act )
result = Manage_Center_Neighborhood_Open(
uwinp, Tilwin_Get_Center( uwinp->winp ), siz );
if (! result)
Draw_Flash();
}
/* ------------------------------------------------------------ */
static void Manage_Act_Hints_Closed( uwinp, pos, siz, pos_act, siz_act )
Userwin *uwinp;
TWPoint pos;
Size siz;
bool pos_act, siz_act;
{
if ( pos_act && siz_act )
Tilwin_Set( uwinp->winp, pos, siz );
else if ( pos_act )
Tilwin_Set( uwinp->winp, pos, Tilwin_Get_Center( uwinp->winp ) );
else if ( siz_act )
Tilwin_Set( uwinp->winp, Tilwin_Get_Center( uwinp->winp ), siz );
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Geometry_Hints( uwinp, flags,
top_left, size )
Userwin *uwinp;
long flags;
TWPoint top_left;
Size size;
{
Size siz;
TWRectangle rect;
TWPoint pos;
bool pos_act, siz_act;
bool by_user;
if (! uwinp->prepared)
Manage_Prepare( uwinp );
Manage_Start();
Manage_Save_State( uwinp );
if ( uwinp->zoomed )
{
uwinp->zoom_min = Tilwin_Get_Min(uwinp->winp);
uwinp->zoom_size = Tilwin_Get_Desired(uwinp->winp);
}
else
{
uwinp->regular_min = Tilwin_Get_Min(uwinp->winp);
uwinp->regular_size = Tilwin_Get_Desired(uwinp->winp);
}
by_user =
( Size_Hints_User_Position(flags) ||
Size_Hints_User_Size(flags) );
/* - - - - - - - - - - - - - - - - - - - - - - - - */
if (! Manage_Use_Size( uwinp, flags) )
size = Region_Unadjust_Size( uwinp, uwinp->regular_size );
rect = Region_Body_Rectangle( uwinp );
if ( Manage_Use_Position( uwinp, flags) )
{
uwinp->positioned = TRUE;
rect.top_y = top_left.y;
rect.left_x = top_left.x;
}
rect.right_x = rect.left_x + size.width - 1;
rect.bottom_y = rect.top_y + size.height - 1;
rect = Region_Adjust_Rectangle( uwinp, rect );
COMPUTE_CENTER( rect, pos );
if ( Manage_Use_Position( uwinp, flags ) )
Tilwin_Set_Position( uwinp->winp, pos );
COMPUTE_SIZE( rect, size );
if ( ! uwinp->ever_opened )
{
if ( Profile_Supplies_User_Value( uwinp, NORMAL_DESIRED_WIDTH ) )
size.width = uwinp->regular_size.width;
if ( Profile_Supplies_User_Value( uwinp, NORMAL_DESIRED_HEIGHT ) )
size.height = uwinp->regular_size.height;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - */
siz_act = Size_Hints_User_Size(flags);
if ( Userwin_Get_Window_Option( uwinp,
ENFORCE_CLIENT_MINIMUMS ) )
Set_Max_Size( size, size, uwinp->client_min );
if ( Userwin_Get_Window_Option( uwinp,
ENFORCE_CLIENT_MAXIMUMS ) )
Set_Min_Size( size, size, uwinp->client_max );
if ( Size_Hints_User_Size(flags) )
{
if ( UserGlobals_Get_Option(RESET_MIN_ON_DECREASE) )
Set_Min_Size( uwinp->regular_min, uwinp->regular_min, size )
else
Set_Max_Size( size, size, uwinp->regular_min );
if ( UserGlobals_Get_Option(RESET_MAX_ON_INCREASE) )
{
Set_Max_Size( siz, Tilwin_Get_Max( uwinp->winp ), size );
Tilwin_Set_Max( uwinp->winp, siz );
}
else
Set_Min_Size( size, size, Tilwin_Get_Max( uwinp->winp ) );
}
else
{
Set_Min_Size( size, size, Tilwin_Get_Max( uwinp->winp ) );
Set_Max_Size( size, size, uwinp->regular_min );
}
if ( Manage_Use_Size( uwinp, flags ) )
{
uwinp->sized = TRUE;
uwinp->regular_size = size;
}
else
if ( uwinp->zoomed )
siz_act = FALSE;
/* - - - - - - - - - - - - - - - - - - - - - - - - */
pos_act = Size_Hints_User_Position(flags);
Set_Max_Size( uwinp->zoom_size,
uwinp->zoom_size, uwinp->regular_size );
Set_Max_Size( uwinp->zoom_min,
uwinp->zoom_min, uwinp->regular_min );
if ( uwinp->zoomed )
{
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
else
{
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
if ( (! ( siz_act || pos_act ) ) ||
( (! uwinp->ever_opened) && uwinp->layout_found ) )
{
Manage_Finish( TRUE );
if (! by_user)
Manage_Cant_Undo();
}
else if (! Userwin_Is_Open(uwinp) )
{
Manage_Act_Hints_Closed( uwinp, pos, size,
pos_act, siz_act );
Manage_Finish( TRUE );
Manage_Cant_Undo();
}
else if ( by_user )
{
Manage_Act_Hints_Open( uwinp, pos, size,
pos_act, siz_act );
Manage_Finish_Minned( uwinp, TRUE );
}
else
Manage_Client_Finish_Minned( uwinp,
Manage_Act_Hints_Open( uwinp, pos, size,
pos_act, siz_act ) );
}
/* ------------------------------------------------------------ */
void Manage_Initial_Geometry( uwinp, top_left, bodsiz )
Userwin *uwinp;
TWPoint top_left;
Size bodsiz;
{
TWPoint center;
Size siz;
TWRectangle rect;
if (! uwinp->prepared)
Manage_Prepare( uwinp );
rect.left_x = top_left.x;
rect.top_y = top_left.y;
rect.right_x = rect.left_x + bodsiz.width - 1;
rect.bottom_y = rect.top_y + bodsiz.height - 1;
rect = Region_Adjust_Rectangle( uwinp, rect );
COMPUTE_CENTER( rect, center );
COMPUTE_SIZE( rect, siz );
if ( Profile_Supplies_User_Value( uwinp, NORMAL_DESIRED_WIDTH ) )
siz.width = uwinp->regular_size.width;
if ( Profile_Supplies_User_Value( uwinp, NORMAL_DESIRED_HEIGHT ) )
siz.height = uwinp->regular_size.height;
Set_Min_Size( siz, siz, Tilwin_Get_Max( uwinp->winp ) );
Set_Max_Size( siz, siz, Tilwin_Get_Min( uwinp->winp ) );
Tilwin_Set_Desired( uwinp->winp, siz );
Tilwin_Set( uwinp->winp, center, siz );
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Normal_Hints( uwinp, flags,
min_size, max_size, incr_size,
min_aspect, max_aspect, base_size )
Userwin *uwinp;
long flags;
Size min_size, max_size, incr_size, base_size;
TWPoint min_aspect, max_aspect;
{
Size siz;
bool act = FALSE;
if (! uwinp->prepared)
Manage_Prepare( uwinp );
Manage_Start();
Manage_Save_State( uwinp );
if ( uwinp->zoomed )
{
uwinp->zoom_min = Tilwin_Get_Min(uwinp->winp);
uwinp->zoom_size = Tilwin_Get_Desired(uwinp->winp);
}
else
{
uwinp->regular_min = Tilwin_Get_Min(uwinp->winp);
uwinp->regular_size = Tilwin_Get_Desired(uwinp->winp);
}
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MAX_WIDTH ) )
max_size.width = uwinp->body_max.width;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MAX_HEIGHT ) )
max_size.height = uwinp->body_max.height;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MIN_WIDTH ) )
min_size.width = uwinp->body_min.width;
if ( Profile_Supplies_User_Value( uwinp, CLIENT_MIN_HEIGHT ) )
min_size.height = uwinp->body_min.height;
/* - - - - - - - - - - - - - - - - - - - - - - - - */
if ( Size_Hints_Max(flags) )
{
if ( Size_Hints_Min(flags) )
Set_Max_Size( max_size, max_size, min_size )
else if ( Size_Hints_Base(flags) )
{
min_size = base_size;
Set_Max_Size( max_size, max_size, min_size )
}
uwinp->client_max = Region_Adjust_Size( uwinp, max_size );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MAXIMUMS ) )
{
if ( Userwin_Get_Window_Option( uwinp,
AUTO_RESATISFY_ON_RESET_MINMAX ) )
act = TRUE;
Set_Min_Size( siz, Tilwin_Get_Max( uwinp->winp ),
uwinp->client_max )
Tilwin_Set_Max( uwinp->winp, siz );
Set_Min_Size( uwinp->regular_min,
uwinp->regular_min, uwinp->client_max );
Set_Min_Size( uwinp->regular_size,
uwinp->regular_size, uwinp->client_max )
}
}
if ( Size_Hints_Min(flags) || Size_Hints_Base(flags) )
{
uwinp->body_min = min_size;
uwinp->client_min = Region_Adjust_Size( uwinp, min_size );
if ( Userwin_Get_Window_Option( uwinp, ENFORCE_CLIENT_MINIMUMS ) )
{
if ( Userwin_Get_Window_Option( uwinp,
AUTO_RESATISFY_ON_RESET_MINMAX ) )
act = TRUE;
Set_Max_Size( siz, Tilwin_Get_Min( uwinp->winp ),
uwinp->client_min )
Tilwin_Set_Min( uwinp->winp, siz );
Set_Max_Size( uwinp->regular_min,
uwinp->regular_min, uwinp->client_min );
Set_Max_Size( uwinp->regular_size,
uwinp->regular_size, uwinp->client_min );
}
}
if ( Same_Size( Tilwin_Get_Min(uwinp->winp),
Tilwin_Get_Max(uwinp->winp) ) )
uwinp->sized = TRUE;
Set_Max_Size( uwinp->zoom_size,
uwinp->zoom_size, uwinp->regular_size );
Set_Max_Size( uwinp->zoom_min,
uwinp->zoom_min, uwinp->regular_min );
if ( uwinp->zoomed )
{
Tilwin_Set_Min( uwinp->winp, uwinp->zoom_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->zoom_size );
}
else
{
Tilwin_Set_Min( uwinp->winp, uwinp->regular_min );
Tilwin_Set_Desired( uwinp->winp, uwinp->regular_size );
}
if ( !act ||
( (! uwinp->ever_opened) && uwinp->layout_found ) )
{
Manage_Finish( TRUE );
Manage_Cant_Undo();
}
else if (! Userwin_Is_Open(uwinp) )
{
Manage_Resatisfy( uwinp );
Manage_Finish( TRUE );
Manage_Cant_Undo();
}
else
Manage_Client_Finish_Minned( uwinp,
{
if( ! Manage_Resatisfy( uwinp ) )
Draw_Flash();
} )
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
extern bool Manage_Fixed_Open();
extern bool Manage_User_Open_Automatically();
/* ------------------------------------------------------------ */
bool Manage_Client_Open_Automatically( uwinp )
Userwin *uwinp;
{
bool result = FALSE;
if ( ! uwinp->ever_opened )
{
Manage_Start();
if ( uwinp->sized && uwinp->positioned )
Manage_Client(
global_excursion( ENABLE_GRAVITY, FALSE,
{
result = Manage_Fixed_Open( uwinp );
} ) )
if (! result)
Manage_Client(
{
result = Manage_User_Open_Automatically(
uwinp, FALSE, FALSE );
} )
if (! result)
Manage_Client(
Manage_Initial_Icon_Open( uwinp ) );
uwinp->ever_opened = TRUE;
Manage_Finish( TRUE );
}
else
Manage_Client(
{
result = Manage_User_Open_Automatically(
uwinp, FALSE, FALSE );
} )
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static bool Manage_Exchange_Open( uwinp, pos, siz )
Userwin *uwinp;
TWPoint pos;
Size siz;
{
bool result;
Manage_Start_Trying();
result = Manage_Center_Neighborhood_Open( uwinp, pos, siz );
if ( (! result) && Manage_Can_Try_Listener_Unzoom() )
result = Manage_Center_Neighborhood_Open( uwinp, pos, siz );
Manage_Finish_Trying( result );
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Icon_Exchange_Open( uwinp, pos )
Userwin *uwinp;
TWPoint pos;
{
bool result;
result = Manage_Neighborhood_Icon_Open( uwinp, pos );
if (! result)
result = Manage_Icon_Open( uwinp );
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Icon_Exchange( uwinp1, uwinp2 )
Userwin *uwinp1, *uwinp2;
{
bool result;
TWPoint pt1, pt2;
pt1 = Tilwin_Get_Center( uwinp1->iconp );
pt2 = Tilwin_Get_Center( uwinp2->iconp );
Tilwin_Close( uwinp1->iconp );
global_excursion( PREFER_CLOSE_TO_SHRINK,
UserGlobals_Get_Option(PREFER_CL_TO_SHR_ON_EXCHANGE),
global_restrict_excursion(
ALLOW_AUTOMATIC_CLOSE,
UserGlobals_Get_Option(ALLOW_AUTO_CLOSE_ON_EXCHANGE),
global_restrict_excursion(
ALLOW_AUTOMATIC_SHRINK,
UserGlobals_Get_Option(ALLOW_AUTO_SHRINK_ON_EXCHANGE),
{
result = Manage_Icon_Exchange_Open( uwinp2, pt1 );
if ( result )
result = Manage_Icon_Exchange_Open( uwinp1, pt2 );
} ) ) )
if ( result )
{
Tilwin_Set_Position( uwinp1->iconp, pt2 );
Tilwin_Set_Position( uwinp2->iconp, pt1 );
}
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Open_Exchange( uwinp1, uwinp2 )
Userwin *uwinp1, *uwinp2;
{
TWPoint pt1, pt2;
Size siz;
bool result;
Manage_Restart();
pt1 = Tilwin_Get_Center( uwinp1->winp );
pt2 = Tilwin_Get_Center( uwinp2->winp );
Tilwin_Close( uwinp1->winp );
user_global_restrict_excursion(
UNZOOM_TIED_LSNR_IF_NECESSARY,
( ( listener != uwinp1 ) && ( listener != uwinp2 ) ),
global_excursion( PREFER_CLOSE_TO_SHRINK,
UserGlobals_Get_Option(PREFER_CL_TO_SHR_ON_EXCHANGE),
global_restrict_excursion(
ALLOW_AUTOMATIC_CLOSE,
UserGlobals_Get_Option(ALLOW_AUTO_CLOSE_ON_EXCHANGE),
global_restrict_excursion(
ALLOW_AUTOMATIC_SHRINK,
UserGlobals_Get_Option(ALLOW_AUTO_SHRINK_ON_EXCHANGE),
{
siz = Tilwin_Checked_Desired_Size( uwinp2->winp );
result = Manage_Exchange_Open( uwinp2, pt1, siz );
if ( result )
window_excursion( uwinp2->winp, REQUIRE_MANUAL_CLOSE, TRUE,
{
siz = Tilwin_Checked_Desired_Size( uwinp1->winp );
result = Manage_Exchange_Open( uwinp1, pt2, siz );
} )
} ) ) ) )
if ( result )
{
Tilwin_Set_Position( uwinp1->winp, pt2 );
uwinp1->positioned = TRUE;
Tilwin_Set_Position( uwinp2->winp, pt1 );
uwinp2->positioned = TRUE;
}
return result;
}
/* ------------------------------------------------------------ */
static bool Manage_Different_Exchange( uwinp1, uwinp2 )
Userwin *uwinp1, *uwinp2;
{
TWPoint pt1, pt2;
Size siz;
bool result;
bool repos1 = FALSE;
bool repos2 = FALSE;
if ( uwinp2 == rtl_uwinp ) return FALSE;
Manage_Restart();
pt1 = Tilwin_Get_Center( uwinp1->winp );
pt2 = Tilwin_Get_Center( uwinp2->iconp );
Tilwin_Close( uwinp1->winp );
Tilwin_Close( uwinp2->iconp );
user_global_restrict_excursion(
UNZOOM_TIED_LSNR_IF_NECESSARY,
( listener != uwinp1 ),
{ global_excursion( PREFER_CLOSE_TO_SHRINK,
UserGlobals_Get_Option(PREFER_CL_TO_SHR_ON_EXCHANGE),
{ global_restrict_excursion(
ALLOW_AUTOMATIC_CLOSE,
UserGlobals_Get_Option(ALLOW_AUTO_CLOSE_ON_EXCHANGE),
{ global_restrict_excursion(
ALLOW_AUTOMATIC_SHRINK,
UserGlobals_Get_Option(ALLOW_AUTO_SHRINK_ON_EXCHANGE),
{
siz = Tilwin_Checked_Desired_Size( uwinp2->winp );
if ( UserGlobals_Get_Option(PREFER_EXCHANGED_LOC_ON_OPENING) &&
(! ( uwinp2->positioned &&
Userwin_Get_Window_Option( uwinp2,
REQUIRE_PREV_POS ) ) ) )
{
result = Manage_Exchange_Open( uwinp2, pt1, siz );
if ( result )
repos2 = TRUE;
}
if (! result)
result = Manage_Desktop_Open( uwinp2, siz );
} ) } ) } ) } )
if (! result)
return FALSE;
window_excursion( uwinp2->winp, REQUIRE_MANUAL_CLOSE, TRUE,
{
if ( UserGlobals_Get_Option(
PREFER_EXC_LOC_ON_ICONIZING) )
{
if ( Manage_Neighborhood_Icon_Open( uwinp1, pt2 ) )
repos1 = TRUE;
else
Manage_Icon_Open( uwinp1 );
}
else
Manage_Icon_Open( uwinp1 );
} )
if ( repos1 )
Tilwin_Set_Position( uwinp1->iconp, pt2 );
if ( repos2 )
{
Tilwin_Set_Position( uwinp2->winp, pt1 );
uwinp2->positioned = TRUE;
}
return TRUE;
}
/* ------------------------------------------------------------ */
bool Manage_Exchange( uwinp1, uwinp2 )
Userwin *uwinp1, *uwinp2;
{
bool open1, open2;
bool result;
Manage_Start();
open1 = ( uwinp1->current_type == body );
open2 = ( uwinp2->current_type == body );
if ( open1 && (! open2) )
{
result = Manage_Different_Exchange( uwinp1, uwinp2 );
Manage_Finish_Locked( uwinp2, result );
}
else if ( open2 && (! open1) )
{
result = Manage_Different_Exchange( uwinp2, uwinp1 );
Manage_Finish_Locked( uwinp1, result );
}
else if ( (! open1) && (! open2) )
{
result = Manage_Icon_Exchange( uwinp1, uwinp2 );
Manage_Finish( result );
}
else
{
result = FALSE;
if ( UserGlobals_Get_Option(
TRY_CTR_NBRHD_ON_EXCHANGE) &&
UserGlobals_Get_Option(
TRY_CTR_NBRHD_ON_OPEN) )
{
result = Manage_Open_Exchange( uwinp1, uwinp2 );
if (! result)
result = Manage_Open_Exchange( uwinp2, uwinp1 );
}
if (! result)
user_global_excursion(
TRY_CTR_NBRHD_ON_OPEN, FALSE,
{
result = Manage_Open_Exchange( uwinp1, uwinp2 );
if (! result)
result = Manage_Open_Exchange( uwinp2, uwinp1 );
} )
window_excursion( uwinp1->winp, REQUIRE_MANUAL_CLOSE, TRUE,
window_excursion( uwinp2->winp, REQUIRE_MANUAL_CLOSE, TRUE,
Manage_Finish( result ) ) );
}
return result;
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static void Manage_Remove_Window( uwinp )
Userwin *uwinp;
{
TimeStamp stamp;
Manage_Start();
if ( Tilwin_Is_Open( uwinp->winp ) )
{
Tilwin_Close( uwinp->winp );
if ( UserGlobals_Get_Option(AUTO_REPOPULATE_ON_CLOSE) )
{
if ( UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Manage_Ordered_Desire();
if ( UserGlobals_Get_Option(ONLY_REPOPULATE_SINCE_ON_CLOSE) )
stamp = uwinp->open_stamp;
else
stamp = (TimeStamp)0;
Manage_Repopulate_Since( stamp, FALSE, FALSE, TRUE );
}
}
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
static void Manage_Remove( uwinp )
Userwin *uwinp;
{
if ( Tilwin_Is_Open( uwinp->winp ) )
Tilwin_Close( uwinp->winp );
else if ( Tilwin_Is_Open( uwinp->iconp ) )
Tilwin_Close( uwinp->iconp );
Closed_Remove( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Close( uwinp )
Userwin *uwinp;
{
extern void Manage_Contract();
if ( uwinp->client_state != ClientIconState )
Manage_Remove_Window( uwinp );
else if ( Same_Size( Tilwin_Get_Min(uwinp->winp),
Tilwin_Get_Size(uwinp->winp) ) )
Manage_Remove_Window( uwinp );
else
Manage_Contract( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Client_Close( uwinp )
Userwin *uwinp;
{
Manage_Client( Manage_Remove_Window( uwinp ) );
}
/* ------------------------------------------------------------ */
void Manage_Client_Open_Icon( uwinp )
Userwin *uwinp;
{
if ( uwinp->ever_opened )
Manage_Client_Close( uwinp );
else
{
uwinp->ever_opened = TRUE;
Manage_Client( Manage_Initial_Icon_Open( uwinp ) )
}
}
/* ------------------------------------------------------------ */
static void Manage_Close_Icon( uwinp )
Userwin *uwinp;
{
Manage_Start();
if ( Tilwin_Is_Open( uwinp->iconp ) )
Tilwin_Close( uwinp->iconp );
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
static void Manage_Inactivate( uwinp )
Userwin *uwinp;
{
if ( Tilwin_Is_Open( uwinp->winp ) )
Manage_Remove_Window( uwinp );
else
Manage_Close_Icon( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Client_Close_Icon( uwinp )
Userwin *uwinp;
{
Manage_Client( Manage_Inactivate( uwinp ) )
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Group_Close( uwinp )
Userwin *uwinp;
{
Tilwinp winp;
Userwin *group;
TimeStamp stamp;
group = uwinp->group;
if ( group == UWIN_NULL )
{
Manage_Close( uwinp );
return;
}
Manage_Start();
group->group = group;
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( (uwinp->group == group) &&
(! Tilwin_Is_Open(uwinp->winp)) &&
(! Tilwin_Is_Open(uwinp->iconp)) )
{
Manage_Save_State( uwinp );
Closed_Remove( uwinp );
uwinp->group_state = uwinp->wm_state;
}
}
stamp = last_stamp;
Tilwin_Gen_Open_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( uwinp->group == group )
{
if ( uwinp->winp == winp )
stamp = MIN( stamp, uwinp->open_stamp );
Manage_Save_State( uwinp );
Manage_Remove( uwinp );
uwinp->group_state = uwinp->wm_state;
}
}
if (! group->ever_opened)
Manage_Prepare_Open( group );
Closed_Add( uwinp );
if ( UserGlobals_Get_Option(USE_ICONS) )
Manage_Icon_Open( uwinp );
if ( UserGlobals_Get_Option(AUTO_REPOPULATE_ON_CLOSE) )
{
if ( UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Manage_Ordered_Desire();
if (! UserGlobals_Get_Option(ONLY_REPOPULATE_SINCE_ON_CLOSE) )
stamp = (TimeStamp)0;
Manage_Repopulate_Since( stamp, FALSE, FALSE, TRUE );
}
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
static void Manage_Group_Restore( uwinp )
Userwin *uwinp;
{
int state;
state = uwinp->group_state;
uwinp->group_state = GroupState;
switch ( state )
{
case NeverState:
break;
case NoState:
case DontCareState:
case NormalState:
Closed_Add( uwinp );
Manage_User_Open_Automatically( uwinp, FALSE, FALSE );
break;
case ClientIconState:
case IconicState:
case InactiveState:
Closed_Add( uwinp );
if ( uwinp->client_state == ClientIconState )
Manage_User_Open_Automatically( uwinp, FALSE, FALSE );
else
Manage_Icon_Open( uwinp );
break;
case IgnoreState:
break;
}
}
/* ------------------------------------------------------------ */
void Manage_Group_Open( group )
Userwin *group;
{
bool found = TRUE;
Tilwinp winp;
Userwin *uwinp;
Manage_Start();
Manage_Save_State( group );
if ( Tilwin_Is_Open( group->iconp ) )
Tilwin_Close( group->iconp );
Closed_Remove( group );
while (found)
{
found = FALSE;
Tilwin_Gen_Closed_Windows();
while ( (! found) &&
( (winp = Tilwin_Next_Window()) != WIN_NULL ) )
{
uwinp = Userwin_Get(winp);
if ( Userwin_Group_Closed( uwinp ) &&
(uwinp->group == group) )
{
found = TRUE;
Manage_Group_Restore( uwinp );
}
}
}
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Want_State( uwinp, state )
Userwin *uwinp;
int state;
{
uwinp->group_state = state;
}
/* ------------------------------------------------------------ */
static void Manage_Set_Group( uwinp, group )
Userwin *uwinp;
Userwin *group;
{
Manage_Start();
uwinp->group = group;
if (! Userwin_Group_Closed( uwinp ) )
{
if ( ( group != UWIN_NULL) && Userwin_Group_Closed( group ) )
{
Manage_Save_State( uwinp );
Manage_Remove( uwinp );
uwinp->group_state = uwinp->wm_state;
}
}
else if ( ( group == UWIN_NULL ) ||
(! Userwin_Group_Closed( group ) ) )
Manage_Group_Restore( uwinp );
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Group( uwinp, group )
Userwin *uwinp;
Userwin *group;
{
Manage_Client( Manage_Set_Group( uwinp, group ) )
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Client_Set_State( uwinp, state )
Userwin *uwinp;
int state;
{
uwinp->client_state = state;
}
/* ------------------------------------------------------------ */
void Manage_Client_Change_State( uwinp, state )
Userwin *uwinp;
int state;
{
uwinp->client_state = state;
if ( ( state != IgnoreState ) &&
( uwinp->wm_state == IgnoreState ) )
Drawwin_Insert( uwinp );
else if ( ( state == IgnoreState ) &&
( uwinp->wm_state != IgnoreState ) )
Drawwin_Withdraw( uwinp );
if ( Userwin_Group_Closed( uwinp ) )
{
if ( state == IgnoreState )
{
if ( (uwinp->wm_state != IgnoreState) &&
(uwinp->group != uwinp) )
{
uwinp->wm_state = IgnoreState;
Client_Set_State( uwinp );
}
uwinp->group_state = IgnoreState;
}
else
{
if ( uwinp->wm_state == IgnoreState )
{
uwinp->wm_state = InactiveState;
uwinp->group_state = state;
Client_Set_State( uwinp );
}
else if ( ( state != NoState ) && ( state != DontCareState ) )
uwinp->group_state = state;
}
}
else
{
switch ( state )
{
case NoState:
case DontCareState:
break;
case NormalState:
case ClientIconState:
if (! Tilwin_Is_Open( uwinp->winp ) )
Manage_Client_Open_Automatically( uwinp );
break;
case IconicState:
Manage_Client( Manage_Remove_Window( uwinp ) );
break;
case InactiveState:
if ( Tilwin_Is_Open(uwinp->winp) ||
Tilwin_Is_Open(uwinp->iconp) )
Manage_Client( Manage_Inactivate( uwinp ) )
uwinp->wm_state = InactiveState;
Client_Set_State( uwinp );
Closed_Add( uwinp );
break;
case IgnoreState:
if ( Tilwin_Is_Open(uwinp->winp) ||
Tilwin_Is_Open(uwinp->iconp) )
Manage_Client( Manage_Inactivate( uwinp ) )
uwinp->wm_state = IgnoreState;
Client_Set_State( uwinp );
Closed_Remove( uwinp );
break;
}
}
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
void Manage_Repopulate_Last()
{
Manage_Start();
Manage_Repopulate_Since( last_stamp, TRUE, FALSE, TRUE );
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Repopulate_All( strict, only_auto_close )
bool strict;
bool only_auto_close;
{
Manage_Start();
Manage_Repopulate_Since( (TimeStamp)0, TRUE, strict, only_auto_close );
Manage_Finish( TRUE );
}
/* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
static void Manage_Cleanup_Window( uwinp )
Userwin *uwinp;
{
if ( uwinp == prev_touch ) prev_touch = UWIN_NULL;
if ( uwinp == prev_listener ) prev_listener = UWIN_NULL;
Manage_Unset( uwinp );
/* So Update Desktop treats correctly */
uwinp->client_state = NeverState;
Manage_Remove( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Eliminate_Window( uwinp )
Userwin *uwinp;
{
Manage_Untitle( uwinp );
Drawwin_Destroy( uwinp );
DrawIcon_Destroy( uwinp );
Tilwin_Destroy_Window( uwinp->winp );
Tilwin_Destroy_Window( uwinp->iconp );
Userwin_Deallocate( uwinp );
}
/* ------------------------------------------------------------ */
static void Manage_Cleanup_Connection( connection )
int connection;
{
Tilwinp winp;
Userwin *uwinp;
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( (uwinp->connection == connection ) &&
( (winp == uwinp->winp) || Tilwin_Is_Open(uwinp->winp) ) )
{
Manage_Cleanup_Window( uwinp );
}
}
}
/* ------------------------------------------------------------ */
static void Manage_Eliminate_Connection( connection )
int connection;
{
Tilwinp winp;
Userwin *uwinp;
bool killed = TRUE;
while (killed)
{
killed = FALSE;
Tilwin_Gen_Closed_Windows();
while ( (! killed) &&
( (winp = Tilwin_Next_Window()) != WIN_NULL ) )
{
uwinp = Userwin_Get(winp);
if ( (uwinp->connection == connection ) &&
( (winp == uwinp->winp) || Tilwin_Is_Open(uwinp->winp) ) )
{
Manage_Eliminate_Window( uwinp );
killed = TRUE;
}
}
}
}
/* ------------------------------------------------------------ */
static void Manage_Destroy_Window( uwinp )
Userwin *uwinp;
{
bool zoomed;
TimeStamp open_stamp, zoom_stamp;
Manage_Start();
if ( UserGlobals_Get_Option(ONLY_REPOPULATE_SINCE_ON_CLOSE) )
open_stamp = uwinp->open_stamp;
else
open_stamp = (TimeStamp)0;
zoomed = uwinp->zoomed;
if ( UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_AUTO_UNZOOM) ||
UserGlobals_Get_Option(
ONLY_REPOP_SINCE_ON_EXPL_UNZOOM) )
zoom_stamp = uwinp->zoom_stamp;
else
zoom_stamp = (TimeStamp)0;
Manage_Cleanup_Window( uwinp );
Manage_Update_Desktop();
Manage_Eliminate_Window( uwinp );
if ( UserGlobals_Get_Option(AUTO_DESIRED_ENLARGE) )
Manage_Ordered_Desire();
if ( UserGlobals_Get_Option(AUTO_REPOPULATE_ON_CLOSE) )
Manage_Repopulate_Since( open_stamp, FALSE, FALSE, TRUE );
if ( zoomed &&
UserGlobals_Get_Option(AUTO_REPOP_ON_EXPLICIT_UNZOOM) )
Manage_Repopulate_Since( zoom_stamp, FALSE, FALSE, TRUE );
Manage_Finish( TRUE );
}
/* ------------------------------------------------------------ */
void Manage_Client_Destroy( uwinp )
Userwin *uwinp;
{
Manage_Unset( uwinp );
Manage_Client( Manage_Destroy_Window( uwinp ) );
}
/* ------------------------------------------------------------ */
void Manage_Hard_Kill( uwinp )
Userwin *uwinp;
{
Client_Kill( uwinp );
Manage_Destroy_Window( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Notify( uwinp )
Userwin *uwinp;
{
if ( Userwin_Bangs( uwinp ) )
{
uwinp->saving_state = TRUE;
Client_Bang( uwinp );
}
else
Draw_Flash();
}
/* ------------------------------------------------------------ */
void Manage_Soft_Kill( uwinp )
Userwin *uwinp;
{
if ( Userwin_Bangs( uwinp ) )
{
uwinp->saving_state = TRUE;
uwinp->soft_kill = TRUE;
Client_Bang( uwinp );
}
else
{
Client_Kill( uwinp );
Manage_Destroy_Window( uwinp );
}
}
/* ------------------------------------------------------------ */
void Manage_Delete_Window( uwinp )
Userwin *uwinp;
{
if ( Userwin_Deletes_Window( uwinp ) )
Client_Delete_Window( uwinp );
else
Manage_Soft_Kill( uwinp );
}
/* ------------------------------------------------------------ */
void Manage_Notify_All()
{
Tilwinp winp;
Userwin *uwinp;
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( (uwinp != rtl_uwinp) &&
( (winp == uwinp->winp) || Tilwin_Is_Open(uwinp->winp) ) )
{
if ( Userwin_Bangs( uwinp ) )
Manage_Notify( uwinp );
}
}
}
/* ------------------------------------------------------------ */
void Manage_Soft_Kill_All()
{
Tilwinp winp;
Userwin *uwinp;
bool killed = TRUE;
while (killed)
{
killed = FALSE;
Tilwin_Gen_Closed_Windows();
while ( (! killed) &&
( (winp = Tilwin_Next_Window()) != WIN_NULL ) )
{
uwinp = Userwin_Get(winp);
if ( (uwinp != rtl_uwinp) &&
( (winp == uwinp->winp) || Tilwin_Is_Open(uwinp->winp) ) )
{
Manage_Soft_Kill( uwinp );
killed = TRUE;
}
}
}
}
/* ------------------------------------------------------------ */
void Manage_Exit()
{
Tilwinp winp;
Userwin *uwinp;
Tilwin_Gen_Closed_Windows();
while ( (winp = Tilwin_Next_Window()) != WIN_NULL )
{
uwinp = Userwin_Get(winp);
if ( (uwinp != rtl_uwinp) &&
( (winp == uwinp->winp) || Tilwin_Is_Open(uwinp->winp) ) )
Client_Kill( uwinp );
}
}
/* ------------------------------------------------------------ */
void Manage_Client_Set_Messages( uwinp, messages )
Userwin *uwinp;
long messages;
{
uwinp->messages = messages;
}
Reference in a new issue View git blame Copy permalink