src/thing.c

   1 /*
   2  * ion/thing.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #include "common.h"
   9 #include "thing.h"
  10 #include "thingp.h"
  11 #include "global.h"
  12 #include "client.h"
  13 #include "wedln.h"
  14 #include "query.h"
  15 #include "grab.h"
  16
  17
  18 IMPLOBJ(WThing, WObj, NULL)
  19
  20
  21 /*{{{ Destroy */
  22
  23
  24 static void do_destroy_thing(WThing *t)
  25 {
  26         WThing *p;
  27
  28         p=t->t_parent;
  29
  30         /* Make sure that any command sequence doesn't try to
  31          * access this thing anymore.
  32          */
  33         query_check_function_thing(t);
  34
  35         destroy_subthings(t);
  36
  37         if(p!=NULL)
  38                 CALL_FUNTAB(p, WThingFuntab, remove_child_fn)(p, t);
  39
  40         grab_remove_for(t);
  41
  42         unlink_thing(t);
  43
  44         CALL_FUNTAB(t, WThingFuntab, deinit_fn)(t);
  45
  46         free(t);
  47
  48         if(wglobal.focus_next==t)
  49                 wglobal.focus_next=NULL;
  50         if(wglobal.grab_holder==t)
  51                 wglobal.grab_holder=NULL;
  52         if(wglobal.previous==t)
  53                 wglobal.previous=p;
  54 }
  55
  56
  57 void destroy_thing(WThing *t)
  58 {
  59         WThing *p;
  60
  61         while(1){
  62                 p=t->t_parent;
  63                 do_destroy_thing(t);
  64
  65                 if(p==NULL)
  66                         break;
  67
  68                 if(!(p->flags&WTHING_DESTREMPTY) || p->t_children!=NULL)
  69                         break;
  70
  71                 t=p;
  72         }
  73 }
  74
  75
  76 void destroy_subthings(WThing *parent)
  77 {
  78         WThing *t, *prev=NULL;
  79
  80         assert(!(parent->flags&WTHING_SUBDEST));
  81
  82         parent->flags|=WTHING_SUBDEST;
  83
  84         /* destroy children */
  85         while(1){
  86                 t=parent->t_children;
  87                 if(t==NULL)
  88                         break;
  89                 assert(t!=prev);
  90                 prev=t;
  91                 do_destroy_thing(t);
  92         }
  93
  94         parent->flags&=~WTHING_SUBDEST;
  95 }
  96
  97
  98 /*}}}*/
  99
 100
 101 /*{{{ Linking */
 102
 103
 104 void link_thing(WThing *parent, WThing *thing)
 105 {
 106         LINK_ITEM(parent->t_children, thing, t_next, t_prev);
 107         thing->t_parent=parent;
 108 }
 109
 110
 111 /*void link_thing_before(WThing *before, WThing *thing)
 112 {
 113         WThing *parent=before->t_parent;
 114         LINK_ITEM_BEFORE(parent->t_children, before, thing, t_next, t_prev);
 115         thing->t_parent=parent;
 116 }*/
 117
 118
 119 void link_thing_after(WThing *after, WThing *thing)
 120 {
 121         WThing *parent=after->t_parent;
 122         LINK_ITEM_AFTER(parent->t_children, after, thing, t_next, t_prev);
 123         thing->t_parent=parent;
 124 }
 125
 126
 127 void unlink_thing(WThing *thing)
 128 {
 129         WThing *parent=thing->t_parent;
 130
 131         if(parent==NULL)
 132                 return;
 133
 134         UNLINK_ITEM(parent->t_children, thing, t_next, t_prev);
 135         thing->t_parent=NULL;
 136 }
 137
 138
 139 /*}}}*/
 140
 141
 142 /*{{{ Scan */
 143
 144
 145 static WThing *get_next_thing(WThing *first, const WObjDescr *descr)
 146 {
 147         while(first!=NULL){
 148                 if(wobj_is((WObj*)first, descr))
 149                         break;
 150                 first=first->t_next;
 151         }
 152
 153         return first;
 154 }
 155
 156
 157 static WThing *get_prev_thing(WThing *first, const WObjDescr *descr)
 158 {
 159         if(first==NULL)
 160                 return NULL;
 161
 162         while(1){
 163                 first=first->t_prev;
 164                 if(first->t_next==NULL)
 165                         return NULL;
 166                 if(wobj_is((WObj*)first, descr))
 167                         break;
 168         }
 169
 170         return first;
 171 }
 172
 173
 174 WThing *next_thing(WThing *first, const WObjDescr *descr)
 175 {
 176         if(first==NULL)
 177                 return NULL;
 178
 179         return get_next_thing(first->t_next, descr);
 180 }
 181
 182
 183 WThing *prev_thing(WThing *first, const WObjDescr *descr)
 184 {
 185         if(first==NULL)
 186                 return NULL;
 187
 188         return get_prev_thing(first, descr);
 189 }
 190
 191
 192 WThing *first_thing(WThing *parent, const WObjDescr *descr)
 193 {
 194         if(parent==NULL)
 195                 return NULL;
 196
 197         return get_next_thing(parent->t_children, descr);
 198 }
 199
 200
 201 WThing *last_thing(WThing *parent, const WObjDescr *descr)
 202 {
 203         WThing *p;
 204
 205         if(parent==NULL)
 206                 return NULL;
 207
 208         p=parent->t_children;
 209
 210         if(p==NULL)
 211                 return NULL;
 212
 213         p=p->t_prev;
 214
 215         if(wobj_is((WObj*)p, descr))
 216                 return p;
 217
 218         return get_prev_thing(p, descr);
 219 }
 220
 221
 222 WThing *find_parent(WThing *p, const WObjDescr *descr)
 223 {
 224         while(p!=NULL){
 225                 if(wobj_is((WObj*)p, descr))
 226                         break;
 227                 p=p->t_parent;
 228         }
 229
 230         return p;
 231 }
 232
 233
 234 WThing *nth_thing(WThing *parent, int n, const WObjDescr *descr)
 235 {
 236         WThing *p;
 237
 238         if(n<0)
 239                 return NULL;
 240
 241         p=first_thing(parent, descr);
 242
 243         while(n-- && p!=NULL)
 244                 p=next_thing(p, descr);
 245
 246         return p;
 247 }