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