daemon/indicator_icon_list.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include "common.h"
  19 #include "indicator.h"
  20 #include "indicator_icon_list.h"
  21 #include "indicator_icon_util.h"
  22
  23 static Eina_List *icon_list = NULL;
  24 static Eina_List *nonfixed_icon_list = NULL;
  25
  26 void indicator_icon_object_free(Indicator_Icon_Object *icon)
  27 {
  28         if (icon) {
  29
  30                 if (icon->obj_exist == EINA_TRUE) {
  31                         if (indicator_util_icon_del(icon) == EINA_TRUE) {
  32                                 icon->obj_exist = EINA_FALSE;
  33                                 icon->txt_obj.obj = NULL;
  34                                 icon->img_obj.obj = NULL;
  35                         }
  36                 }
  37         }
  38 }
  39
  40 int indicator_icon_list_free(void)
  41 {
  42         Eina_List *l;
  43         Eina_List *l_next;
  44         Indicator_Icon_Object *data;
  45
  46         retif(icon_list == NULL, OK, "Empty List!");
  47
  48         EINA_LIST_FOREACH_SAFE(icon_list, l, l_next, data) {
  49                 indicator_icon_object_free(data);
  50                 icon_list = eina_list_remove_list(icon_list, l);
  51                 if (eina_error_get())
  52                         return FAIL;
  53         }
  54         eina_list_free(icon_list);
  55         icon_list = NULL;
  56         return eina_error_get();
  57 }
  58
  59 int indicator_icon_list_update(Indicator_Icon_Object *obj)
  60 {
  61         Eina_List *l;
  62
  63         Indicator_Icon_Object *data;
  64
  65         retif(obj == NULL, FAIL, "Invalid parameter!");
  66
  67         if (obj->fixed == EINA_TRUE) {
  68                 icon_list = eina_list_remove(icon_list, obj);
  69
  70                 /* insert object to list */
  71                 EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
  72                         if (data->priority == obj->priority &&
  73                             data->always_top == EINA_TRUE)
  74                                 continue;
  75
  76                         if (data->priority <= obj->priority) {
  77                                 icon_list = eina_list_append_relative_list(
  78                                                 icon_list, obj, l);
  79                                 return eina_error_get();
  80                         }
  81                 }
  82
  83                 /* if finding condition is failed, append it at tail */
  84                 icon_list = eina_list_prepend(icon_list, obj);
  85         } else {
  86                 nonfixed_icon_list = eina_list_remove(nonfixed_icon_list, obj);
  87
  88                 /* insert object to list */
  89                 EINA_LIST_REVERSE_FOREACH(nonfixed_icon_list, l, data) {
  90                         if (data->priority == obj->priority &&
  91                             data->always_top == EINA_TRUE) {
  92                                 continue;
  93                         }
  94                         if (data->priority <= obj->priority) {
  95                                 nonfixed_icon_list =
  96                                         eina_list_append_relative_list(
  97                                                 nonfixed_icon_list, obj, l);
  98                                 return eina_error_get();
  99                         }
 100                 }
 101
 102                 /* if finding condition is failed, append it at tail */
 103                 nonfixed_icon_list = eina_list_prepend(nonfixed_icon_list, obj);
 104         }
 105         return eina_error_get();
 106 }
 107
 108 int indicator_icon_list_insert(Indicator_Icon_Object *obj)
 109 {
 110         Eina_List *l;
 111         Indicator_Icon_Object *data;
 112
 113         retif(obj == NULL || obj->name == NULL, FAIL, "Invalid parameter!");
 114
 115         if (obj->fixed == EINA_TRUE) {
 116                 /* check name */
 117                 EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 118                         retif(data->name == obj->name, FAIL,
 119                               "%s is already exist in the list!", obj->name);
 120                 }
 121
 122                 /* Set internal data */
 123                 obj->wish_to_show = EINA_FALSE;
 124
 125                 /* insert object to list */
 126                 EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 127                         if (data->priority == obj->priority
 128                                 && data->always_top == EINA_TRUE)
 129                                 continue;
 130
 131                         if (data->priority <= obj->priority) {
 132                                 icon_list = eina_list_append_relative_list(
 133                                                         icon_list, obj, l);
 134                                         return eina_error_get();
 135                         }
 136                 }
 137                 icon_list = eina_list_prepend(icon_list, obj);
 138         } else {
 139                 /* check name */
 140                 EINA_LIST_REVERSE_FOREACH(nonfixed_icon_list, l, data) {
 141                         retif(data->name == obj->name, FAIL,
 142                               "%s is already exist in the list!", obj->name);
 143                 }
 144
 145                 /* Set internal data */
 146                 obj->wish_to_show = EINA_FALSE;
 147
 148                 /* insert object to list */
 149                 EINA_LIST_REVERSE_FOREACH(nonfixed_icon_list, l, data) {
 150                         if (data->priority == obj->priority &&
 151                                 data->always_top == EINA_TRUE)
 152                                 continue;
 153
 154                         if (data->priority <= obj->priority) {
 155                                 nonfixed_icon_list =
 156                                         eina_list_append_relative_list(
 157                                                 nonfixed_icon_list, obj, l);
 158                                 return eina_error_get();
 159                         }
 160                 }
 161                 /* if finding condition is failed, append it at tail */
 162                 nonfixed_icon_list = eina_list_prepend(nonfixed_icon_list, obj);
 163         }
 164
 165         return eina_error_get();
 166 }
 167
 168 int indicator_icon_list_remove(Indicator_Icon_Object *obj)
 169 {
 170         if (obj->fixed == EINA_TRUE) {
 171                 retif(icon_list == NULL
 172                         || obj == NULL, FAIL, "Invalid parameter!");
 173                 icon_list = eina_list_remove(icon_list, obj);
 174         } else {
 175                 retif(nonfixed_icon_list == NULL
 176                         || obj == NULL, FAIL, "Invalid parameter!");
 177                 nonfixed_icon_list = eina_list_remove(nonfixed_icon_list, obj);
 178         }
 179
 180         return eina_error_get();
 181 }
 182
 183 Indicator_Icon_Object *indicator_get_prev_icon(Indicator_Icon_Object * obj)
 184 {
 185         Eina_List *l;
 186         Indicator_Icon_Object *data;
 187
 188         retif(obj == NULL || obj->name == NULL, NULL, "Invalid parameter!");
 189
 190         if (obj->fixed == EINA_TRUE) {
 191                 EINA_LIST_FOREACH(icon_list, l, data) {
 192                         if (data->name == obj->name)
 193                                 break;
 194                 }
 195         } else {
 196                 EINA_LIST_FOREACH(nonfixed_icon_list, l, data) {
 197                         if (data->name == obj->name)
 198                                 break;
 199                 }
 200         }
 201
 202         retif(l == NULL, NULL, "Cannot find %s in icon list!", obj->name);
 203
 204         for (l = eina_list_prev(l), data = eina_list_data_get(l);
 205              l; l = eina_list_prev(l), data = eina_list_data_get(l)) {
 206                 if (obj->priority == data->priority
 207                         && indicator_util_is_show_icon(data))
 208                         return data;
 209         }
 210         return obj;
 211 }
 212
 213 Indicator_Icon_Object *indicator_get_last_shown_icon(void)
 214 {
 215         Eina_List *l;
 216         Indicator_Icon_Object *data;
 217
 218         retif(icon_list == NULL, NULL, "Invalid parameter!");
 219
 220         EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 221                 if (indicator_util_is_show_icon(data))
 222                         return data;
 223         }
 224         return NULL;
 225 }
 226
 227 Indicator_Icon_Object *indicator_get_first_shown_icon(void)
 228 {
 229         Eina_List *l;
 230         Indicator_Icon_Object *data;
 231
 232         retif(icon_list == NULL, NULL, "Invalid parameter!");
 233
 234         EINA_LIST_FOREACH(icon_list, l, data) {
 235                 if (indicator_util_is_show_icon(data))
 236                         return data;
 237         }
 238         return NULL;
 239 }
 240
 241 Indicator_Icon_Object *indicator_get_hidden_icon(void)
 242 {
 243         Eina_List *l;
 244         Indicator_Icon_Object *data;
 245         int prio;
 246
 247         retif(icon_list == NULL, NULL, "Invalid parameter!");
 248
 249         EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 250                 if (indicator_util_is_show_icon(data)) {
 251                         prio = data->priority;
 252                         break;
 253                 }
 254         }
 255
 256         for (l = eina_list_next(l), data = eina_list_data_get(l);
 257              l; l = eina_list_next(l), data = eina_list_data_get(l)) {
 258                 if (data->wish_to_show == EINA_TRUE && data->priority != prio)
 259                         return data;
 260         }
 261         return NULL;
 262 }
 263
 264 Indicator_Icon_Object
 265 *indicator_get_shown_same_priority_icon_in_fixed_view_list(int prio)
 266 {
 267         Eina_List *l;
 268         Indicator_Icon_Object *data;
 269
 270         retif(icon_list == NULL, NULL, "Invalid parameter!");
 271
 272         EINA_LIST_FOREACH(icon_list, l, data) {
 273                 if (data->priority == prio && data->wish_to_show == EINA_TRUE)
 274                         return data;
 275         }
 276         return NULL;
 277 }
 278
 279 Indicator_Icon_Object
 280 *indicator_get_wish_to_show_icon(Indicator_Icon_Object *obj)
 281 {
 282         Eina_List *l;
 283         Indicator_Icon_Object *data;
 284
 285         DBG("indicator_get_wish_to_show_icon!");
 286         retif(obj == NULL, NULL, "Invalid parameter!");
 287
 288         if (obj->fixed == EINA_TRUE) {
 289                 EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 290                         if (data->priority == obj->priority
 291                                 && data->wish_to_show == EINA_TRUE
 292                                 && data->exist_in_view == EINA_FALSE) {
 293                                 return data;
 294                         }
 295                 }
 296                 return NULL;
 297         } else {
 298                 EINA_LIST_REVERSE_FOREACH(nonfixed_icon_list, l, data) {
 299                         if (data->wish_to_show == EINA_TRUE
 300                                 && data->exist_in_view == EINA_FALSE)
 301                                 return data;
 302                 }
 303                 return NULL;
 304         }
 305 }
 306
 307 Indicator_Icon_Object
 308 *indicator_get_wish_to_remove_icon(Indicator_Icon_Object *obj)
 309 {
 310         Eina_List *l;
 311         Indicator_Icon_Object *data;
 312
 313         retif(obj == NULL, NULL, "Invalid parameter!");
 314
 315         if (obj->fixed == EINA_TRUE) {
 316                 EINA_LIST_REVERSE_FOREACH(icon_list, l, data) {
 317                         if (data->priority == obj->priority
 318                                 && data->wish_to_show == EINA_TRUE)
 319                                 return data;
 320                 }
 321                 return NULL;
 322         } else {
 323                 /* find lowest priority of icon */
 324                 EINA_LIST_FOREACH(nonfixed_icon_list, l, data) {
 325                         if (data->wish_to_show == EINA_TRUE
 326                                 && data->exist_in_view == EINA_TRUE)
 327                                 return data;
 328                 }
 329                 return NULL;
 330         }
 331 }
 332
 333
 334 Indicator_Icon_Object
 335 *indicator_get_lowest_priority_icon_in_wish_show_list(void)
 336 {
 337         Eina_List *l;
 338         Indicator_Icon_Object *data;
 339
 340         EINA_LIST_FOREACH(nonfixed_icon_list, l, data) {
 341                 if (data->wish_to_show == EINA_TRUE
 342                         && data->exist_in_view == EINA_FALSE) {
 343                         DBG("Get Lowest Priority Item : %s", data->name);
 344                         return data;
 345                 }
 346         }
 347
 348         return NULL;
 349 }
 350
 351 Indicator_Icon_Object
 352 *indicator_get_highest_priority_icon_in_wish_show_list(void)
 353 {
 354         Eina_List *l;
 355         Indicator_Icon_Object *data;
 356
 357         EINA_LIST_REVERSE_FOREACH(nonfixed_icon_list, l, data) {
 358                 if (data->wish_to_show == EINA_TRUE
 359                         && data->exist_in_view == EINA_FALSE) {
 360                         DBG("Get Highest Priority Item : %s", data->name);
 361                         return data;
 362                 }
 363         }
 364
 365         return NULL;
 366 }
 367
 368 int indicator_get_same_priority_icons(Eina_List **result,
 369                                       Indicator_Icon_Object *obj)
 370 {
 371         Eina_List *l;
 372         Indicator_Icon_Object *data;
 373
 374         retif(icon_list == NULL || obj == NULL, FAIL, "Invalid parameter!");
 375
 376         EINA_LIST_FOREACH(icon_list, l, data) {
 377                 if (data->priority == obj->priority)
 378                         *result = eina_list_append(*result, data);
 379         }
 380
 381         if (eina_list_count(*result) == 1)
 382                 return FAIL;
 383
 384         return OK;
 385 }