src/client.c

   1 /*
   2  * ion/client.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #include <string.h>
   9 #include <limits.h>
  10
  11 #include "common.h"
  12 #include "client.h"
  13 #include "sizehint.h"
  14 #include "frame.h"
  15 #include "clientwin.h"
  16 #include "global.h"
  17 #include "font.h"
  18 #include "thingp.h"
  19 #include "property.h"
  20 #include "focus.h"
  21 #include "draw.h"
  22 #include "complete.h"
  23
  24
  25 static void client_remove_child(WClient *client, WThing *thing);
  26
  27 static WThingFuntab client_funtab={
  28         deinit_client,
  29         client_remove_child
  30 };
  31
  32 IMPLOBJ(WClient, WThing, &client_funtab)
  33
  34
  35 /*{{{ Create/destroy */
  36
  37
  38 static bool init_client(WClient *client)
  39 {
  40         LINK_ITEM(wglobal.client_list, client, g_client_next, g_client_prev);
  41         client->label=NULL;
  42         client->thing.flags|=WTHING_DESTREMPTY;
  43         client->label_next=client;
  44         client->label_prev=client;
  45         client->label_inst=0;
  46         return TRUE;
  47 }
  48
  49
  50 WClient *create_client(WScreen *scr)
  51 {
  52         CREATETHING_IMPL(WClient, client, scr, (p));
  53 }
  54
  55
  56 void deinit_client(WClient *client)
  57 {
  58         client_unuse_label(client);
  59         UNLINK_ITEM(wglobal.client_list, client, g_client_next, g_client_prev);
  60         if(client->label!=NULL)
  61                 free(client->label);
  62 }
  63
  64
  65 /*}}}*/
  66
  67
  68 /*{{{ Add/remove clientwin */
  69
  70
  71 void client_add_clientwin(WClient *client, WClientWin *cwin)
  72 {
  73         link_thing((WThing*)client, (WThing*)cwin);
  74
  75         if(FIRST_THING(client, WClientWin)==cwin)
  76                 client_use_label(client);
  77
  78         if(CLIENT_HAS_FRAME(client))
  79                 frame_add_clientwin(CLIENT_FRAME(client), client, cwin);
  80 }
  81
  82
  83 static void client_remove_child(WClient *client, WThing *thing)
  84 {
  85         WFrame *frame;
  86         WClientWin *n;
  87
  88         if(!WTHING_IS(thing, WClientWin))
  89                 return;
  90
  91         frame=FIND_PARENT(client, WFrame);
  92
  93         if(frame==NULL || !IS_ACTIVE_FRAME(frame))
  94                 return;
  95
  96         if(frame->current_client!=client)
  97                 return;
  98
  99         unlink_thing(thing);
 100         n=LAST_THING(client, WClientWin);
 101         if(n!=NULL)
 102                 set_focus((WThing*)n);
 103 }
 104
 105
 106 /*}}}*/
 107
 108
 109 /*{{{ Clientwin wrappers */
 110
 111
 112 void hide_client(WClient *client)
 113 {
 114         WClientWin *cwin;
 115
 116         FOR_ALL_TYPED(client, cwin, WClientWin){
 117                 hide_clientwin(cwin);
 118         }
 119 }
 120
 121
 122 void show_client(WClient *client)
 123 {
 124         WClientWin *cwin, *first;
 125
 126         FOR_ALL_TYPED(client, cwin, WClientWin){
 127                 show_clientwin(cwin);
 128         }
 129 }
 130
 131
 132 void focus_client(WClient *client)
 133 {
 134         WClientWin *cwin=LAST_THING(client, WClientWin);
 135
 136         if(cwin!=NULL)
 137                 focus_clientwin(cwin);
 138 }
 139
 140
 141 void close_client(WClient *client)
 142 {
 143         WClientWin *cwin=LAST_THING(client, WClientWin);
 144
 145         if(cwin!=NULL)
 146                 close_clientwin(cwin);
 147 }
 148
 149
 150 void close_client_main(WClient *client)
 151 {
 152         WClientWin *cwin=FIRST_THING(client, WClientWin);
 153
 154         if(cwin!=NULL)
 155                 close_clientwin(cwin);
 156 }
 157
 158
 159 void kill_client(WClient *client)
 160 {
 161         WClientWin *cwin=FIRST_THING(client, WClientWin);
 162
 163         if(cwin!=NULL)
 164                 kill_clientwin(cwin);
 165 }
 166
 167
 168 /*}}}*/
 169
 170
 171 /*{{{ Reparent/fit/reconf */
 172
 173
 174 void reparent_client(WClient *client, Window win, int x, int y)
 175 {
 176         WClientWin *cwin;
 177
 178         FOR_ALL_TYPED(client, cwin, WClientWin){
 179                 reparent_clientwin(cwin, win, x, y);
 180         }
 181 }
 182
 183
 184 void fit_client_frame(WClient *client, WFrame *frame)
 185 {
 186         WClientWin *cwin;
 187
 188         FOR_ALL_TYPED(client, cwin, WClientWin){
 189                 fit_clientwin_frame(cwin, frame);
 190         }
 191 }
 192
 193
 194 void reparent_fit_client_frame(WClient *client, WFrame *frame)
 195 {
 196         WClientWin *cwin;
 197
 198         FOR_ALL_TYPED(client, cwin, WClientWin){
 199                 reparent_fit_clientwin_frame(cwin, frame);
 200         }
 201 }
 202
 203
 204 void reconf_client_frame(WClient *client, WFrame *frame)
 205 {
 206         WClientWin *cwin;
 207
 208         FOR_ALL_TYPED(client, cwin, WClientWin){
 209                 reconf_clientwin_frame(cwin, frame);
 210         }
 211 }
 212
 213
 214 /*}}}*/
 215
 216
 217 /*{{{ Labels */
 218
 219
 220 static char *untitled_label="<untitled>";
 221 static char *empty_label="<empty>";
 222
 223
 224 static const char *client_beg_label(WClient *client)
 225 {
 226         WClientWin *cwin=FIRST_THING(client, WClientWin);
 227
 228         if(cwin==NULL){
 229                 return empty_label;
 230         }else{
 231                 if(cwin->name!=NULL)
 232                         return cwin->name;
 233                 /*else if(cwin->icon_name!=NULL)
 234                         return cwin->icon_name;*/
 235         }
 236         return untitled_label;
 237 }
 238
 239
 240 #define CLIENTNUM_TMPL "<%d>"
 241
 242 void client_make_label(WClient *client, int maxw)
 243 {
 244         const char *str=client_beg_label(client);
 245         char tmp[16];
 246         WGRData *grdata;
 247
 248         if(client->label_inst!=0)
 249                 sprintf(tmp, CLIENTNUM_TMPL, client->label_inst);
 250         else
 251                 *tmp='\0';
 252
 253         if(client->label!=NULL)
 254                 free(client->label);
 255
 256         grdata=GRDATA_OF(client);
 257
 258         client->label=make_label(grdata->tab_font, str, tmp, maxw, NULL);
 259 }
 260
 261
 262 char *client_full_label(WClient *client)
 263 {
 264         const char *str=client_beg_label(client);
 265         char tmp[16];
 266
 267         if(client->label_inst!=0){
 268                 sprintf(tmp, CLIENTNUM_TMPL, client->label_inst);
 269                 return scat(str, tmp);
 270         }else{
 271                 return scopy(str);
 272         }
 273 }
 274
 275
 276 static void use_label(WClient *client, const char *label)
 277 {
 278         WClient *p, *np, *minp=NULL;
 279         int mininst=INT_MAX;
 280         const char *str;
 281
 282         for(p=wglobal.client_list; p!=NULL; p=p->g_client_next){
 283                 if(p==client)
 284                         continue;
 285                 str=client_beg_label(p);
 286                 if(strcmp(str, label)==0)
 287                         break;
 288         }
 289
 290         if(p==NULL)
 291                 return;
 292
 293         for(; ; p=np){
 294                 assert(p!=client);
 295                 np=p->label_next;
 296                 if(p->label_inst+1==np->label_inst){
 297                         continue;
 298                 }else if(p->label_inst>=np->label_inst && np->label_inst!=0){
 299                         mininst=0;
 300                         minp=p;
 301                 }else if(p->label_inst+1<mininst){
 302                         mininst=p->label_inst+1;
 303                         minp=p;
 304                         continue;
 305                 }
 306                 break;
 307         }
 308
 309         assert(minp!=NULL);
 310
 311         np=minp->label_next;
 312         client->label_next=np;
 313         np->label_prev=client;
 314         minp->label_next=client;
 315         client->label_prev=minp;
 316         client->label_inst=mininst;
 317 }
 318
 319
 320 void client_use_label(WClient *client)
 321 {
 322         WFrame *frame;
 323         const char *p=client_beg_label(client);
 324
 325         use_label(client, p);
 326
 327         frame=FIND_PARENT(client, WFrame);
 328
 329         if(frame!=NULL)
 330                 frame_recalc_bar(frame);
 331 }
 332
 333
 334 void client_unuse_label(WClient *client)
 335 {
 336         client->label_next->label_prev=client->label_prev;
 337         client->label_prev->label_next=client->label_next;
 338         client->label_next=client;
 339         client->label_prev=client;
 340         client->label_inst=0;
 341 }
 342
 343
 344 /*}}}*/
 345
 346
 347 /*{{{ Misc. */
 348
 349
 350 void client_toggle_tagged(WClient *client)
 351 {
 352         /* ad hoc */
 353         client->flags^=CLIENT_TAGGED;
 354
 355         if(CLIENT_HAS_FRAME(client))
 356                 draw_frame_bar(CLIENT_FRAME(client), FALSE);
 357 }
 358
 359
 360 void clear_tags()
 361 {
 362         WClient *client;
 363
 364         for(client=wglobal.client_list; client!=NULL; client=client->g_client_next){
 365                 if(!(client->flags&CLIENT_TAGGED))
 366                         continue;
 367                 client->flags&=~CLIENT_TAGGED;
 368                 if(CLIENT_HAS_FRAME(client))
 369                         draw_frame_bar(CLIENT_FRAME(client), FALSE);
 370         }
 371 }
 372
 373
 374 void set_client_frame_id(WClient *client, int id)
 375 {
 376         WClientWin *cwin=FIRST_THING(client, WClientWin);
 377         if(cwin!=NULL)
 378                 set_integer_property(cwin->win, wglobal.atom_frame_id, id);
 379 }
 380
 381
 382 bool goto_window(WWindow *wwin)
 383 {
 384         WWorkspace *ws;
 385
 386         if(wglobal.current_wswindow==wwin)
 387                 return FALSE;
 388
 389         ws=FIND_PARENT(wwin, WWorkspace);
 390
 391         if(ws==NULL)
 392                 return FALSE;
 393
 394         set_previous((WThing*)wwin);
 395         protect_previous();
 396
 397         if(!active_workspace(ws))
 398                 switch_workspace(ws);
 399
 400         warp(wwin);
 401
 402         unprotect_previous();
 403
 404         return TRUE;
 405 }
 406
 407
 408 void goto_client(WClient *client)
 409 {
 410         WFrame *frame=FIND_PARENT(client, WFrame);
 411
 412         if(frame==NULL)
 413                 return;
 414
 415         set_previous((WThing*)client);
 416         protect_previous();
 417
 418         goto_window((WWindow*)frame);
 419
 420         if(frame->current_client!=client)
 421                 frame_switch_client(frame, client);
 422
 423         unprotect_previous();
 424 }
 425
 426
 427 void goto_previous()
 428 {
 429         WThing *t=wglobal.previous;
 430
 431         if(t==NULL)
 432                 return;
 433
 434         if(WTHING_IS(t, WClient))
 435                 goto_client((WClient*)t);
 436         else if(WTHING_IS(t, WWindow))
 437                 goto_window((WWindow*)t);
 438 }
 439
 440 bool goto_client_name(const char *cname)
 441 {
 442         WClient *client=lookup_client(cname);
 443
 444         if(client==NULL)
 445                 return FALSE;
 446
 447         goto_client(client);
 448
 449         return TRUE;
 450 }
 451
 452 /*}}}*/
 453
 454
 455 /*{{{ Lookup */
 456
 457
 458 WClient *lookup_client(const char *cname)
 459 {
 460         WClient *client;
 461         char *name;
 462
 463         for(client=wglobal.client_list;
 464                 client!=NULL;
 465                 client=client->g_client_next){
 466
 467                 name=client_full_label(client);
 468                 if(name==NULL)
 469                         continue;
 470
 471                 if(strcmp(name, cname)){
 472                         free(name);
 473                         continue;
 474                 }
 475
 476                 free(name);
 477
 478                 return client;
 479         }
 480
 481         return NULL;
 482 }
 483
 484
 485 int complete_client(char *nam, char ***cp_ret, char **beg)
 486 {
 487         WClient *client;
 488         char *name;
 489         char **cp;
 490         int n=0, l=strlen(nam);
 491         int lnum=0;
 492
 493         *cp_ret=NULL;
 494
 495 again:
 496
 497         for(client=wglobal.client_list;
 498                 client!=NULL;
 499                 client=client->g_client_next){
 500
 501                 name=(char*)client_full_label(client);
 502                 if(name==NULL)
 503                         continue;
 504
 505                 if((lnum==0 && l && strncmp(name, nam, l)) ||
 506                    (strstr(name, nam)==NULL)){
 507                            free(name);
 508                            continue;
 509                 }
 510
 511                 if(!add_to_complist(cp_ret, &n, name))
 512                         free(name);
 513         }
 514
 515         if(n==0 && lnum==0 && l>1){
 516                 lnum=1;
 517                 goto again;
 518         }
 519
 520         return n;
 521 }
 522
 523
 524 /*}}}*/