src/calc-main.c

   1 /*
   2 *
   3 * Copyright 2012  Samsung Electronics Co., Ltd
   4 *
   5 * Licensed under the Flora License, Version 1.1 (the License);
   6 * you may not use this file except in compliance with the License.
   7 * You may obtain a copy of the License at
   8 *
   9 *    http://floralicense.org/license
  10 *
  11 * Unless required by applicable law or agreed to in writing, software
  12 * distributed under the License is distributed on an AS IS BASIS,
  13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 * See the License for the specific language governing permissions and
  15 * limitations under the License.
  16 *
  17 */
  18 #include <dlog.h>
  19 #include <feedback.h>
  20 #include "calc-main.h"
  21 #include "calc-view.h"
  22 #include <vconf.h>
  23
  24 extern char calculator_input_str[];
  25 extern int calculator_cursor_pos;
  26
  27 extern int cur_fontsize;
  28 extern int default_fontsize;
  29 extern int min_len;
  30 extern int max_len;
  31 extern int small_fontsize;
  32 extern int scientific_result_len;
  33
  34 extern void calc_xxx(struct appdata *ap);       /* will be removed */
  35 extern void _calc_entry_text_set_rotate(struct appdata *ad);
  36 extern void calc_por_pannel_load(struct appdata *ad);
  37 extern void calc_lans_pannel_load(struct appdata *ad);
  38 Evas_Object *load_edj(Evas_Object * parent, const char *file, const char *group)
  39 {
  40         CALC_FUN_BEG();
  41         Evas_Object *eo;
  42         int r;
  43         eo = elm_layout_add(parent);
  44         if (eo) {
  45                 r = elm_layout_file_set(eo, file, group);
  46                 if (!r) {
  47                         evas_object_del(eo);
  48                         return NULL;
  49                 }
  50                 evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND,
  51                                                  EVAS_HINT_EXPAND);
  52         }
  53         CALC_FUN_END();
  54         return eo;
  55 }
  56
  57 /**
  58 * @describe
  59 * @When rotate to landscape view (Scientific calculation)
  60 * @param[in]    ad      The appdata
  61 * @param[in]    angle   The rotate angle 90 or 270
  62 * @return       void
  63 * @exception
  64 */
  65 static void __to_landscape(struct appdata *ad, int angle)
  66 {
  67         CALC_FUN_BEG();
  68         if (ad == NULL) {
  69                 return;
  70         }
  71         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
  72         calc_lans_pannel_load(ad);
  73         edje_object_signal_emit(_EDJ(ad->edje), "landscape", "");
  74         elm_win_rotation_with_resize_set(ad->win, angle);
  75         //elm_win_rotation_with_resize_set(ad->eo, angle);/*when rotating, resize the window eo*/
  76         default_fontsize = 98;
  77         cur_fontsize = 98;
  78         small_fontsize = 98;
  79         min_len = 30;
  80         max_len = 37;
  81         scientific_result_len = 13;
  82         _calc_entry_text_set_rotate(ad);
  83         if (!ad->panel_show) {
  84                 calc_view_show_histroy(ad->hist_area);
  85                 edje_object_signal_emit(_EDJ(ad->edje), "show,hist", "");
  86         }
  87         CALC_FUN_END();
  88 }
  89
  90 /**
  91 * @describe
  92 * @When rotate to protrait view (Basic calculation)
  93 * @param[in]    ad      The appdata
  94 * @param[in]    angle   The rotate angle 0 or 180
  95 * @return       void
  96 * @exception
  97 */
  98 static void __to_portrait(struct appdata *ad, int angle)
  99 {
 100     CALC_FUN_BEG();
 101         if (ad == NULL) {
 102                 return;
 103         }
 104         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
 105         calc_por_pannel_load(ad);
 106         edje_object_signal_emit(_EDJ(ad->edje), "portrait", "");
 107         elm_win_rotation_with_resize_set(ad->win, angle);
 108         //elm_win_rotation_with_resize_set(ad->eo, angle);/*when rotating, resize the window eo*/
 109         default_fontsize = 70;
 110         cur_fontsize = 70;
 111         small_fontsize = 58;
 112         min_len = 13;
 113         max_len = 16;
 114         scientific_result_len = 8;
 115         _calc_entry_text_set_rotate(ad);
 116         if (!ad->panel_show) {
 117                 calc_view_show_histroy(ad->hist_area);
 118                 edje_object_signal_emit(_EDJ(ad->edje), "show,hist", "");
 119         }
 120         CALC_FUN_END();
 121 }
 122
 123 /**
 124 * @describe
 125 *
 126 *
 127 * @param    mode
 128 * @param    data
 129 * @return    int
 130 * @exception
 131 */
 132 static  void _rotate(app_device_orientation_e  mode, void *data)
 133 {
 134         CALC_FUN_BEG();
 135         if (data == NULL) {
 136                 return;
 137         }
 138         struct appdata *ad = (struct appdata *)data;
 139
 140         switch (mode) {
 141         case APP_DEVICE_ORIENTATION_0:  //[1]0
 142                 __to_portrait(ad, 0);
 143                 break;
 144
 145         case APP_DEVICE_ORIENTATION_180:        //[2]180
 146                 __to_portrait(ad, 180);
 147                 break;
 148
 149         case APP_DEVICE_ORIENTATION_270:        //[3]-90
 150                 __to_landscape(ad, 270);
 151                 break;
 152
 153         case APP_DEVICE_ORIENTATION_90: //[4]90
 154                 __to_landscape(ad, 90);
 155                 break;
 156
 157         default:
 158                 break;
 159         }
 160                 if (!ad->panel_show) {
 161                         calc_view_revise_history_scroller(ad);
 162                 } else {
 163                         calc_view_revise_input_scroller(ad);
 164                 }
 165
 166         /* When rotate, the size of input scroller will be changed. So it should adjust to cursor position. */
 167         calc_view_revise_input_scroller(ad);
 168         CALC_FUN_END();
 169 }
 170
 171 /**
 172 * @describe
 173 *
 174 *
 175 * @param    data
 176 * @param    obj
 177 * @param    event_info
 178 * @return    void
 179 * @exception
 180 */
 181 static void _win_del(void *data, Evas_Object * obj, void *event_info)
 182 {
 183         elm_exit();
 184 }
 185
 186 /**
 187 * @describe
 188 *
 189 *
 190 * @param    data
 191 * @return    int
 192 * @exception
 193 */
 194 static int _set_input_entry_focus(void *data)
 195 {
 196         CALC_FUN_BEG();
 197         struct appdata *ad = (struct appdata *)data;
 198         elm_object_focus_set(ad->input_entry, EINA_TRUE);       //set focus
 199         _calc_entry_clear(ad->input_entry);
 200         CALC_FUN_END();
 201         return ECORE_CALLBACK_CANCEL;   //0
 202 }
 203
 204 /**
 205 * @describe
 206 *
 207 *
 208 * @param    data
 209 * @return    int
 210 * @exception
 211 */
 212 static int _load_idle_view(void *data)
 213 {
 214         CALC_FUN_BEG();
 215         struct appdata *ad = (struct appdata *)data;
 216         calc_view_load_in_idle(ad);
 217         CALC_FUN_END();
 218         return ECORE_CALLBACK_CANCEL;   //0
 219 }
 220
 221 /**
 222 * @describe
 223 *
 224 *
 225 * @param    name
 226 * @return    Evas_Object*
 227 * @exception
 228 */
 229 static Evas_Object *_create_win(const char *name)
 230 {
 231     CALC_FUN_BEG();
 232         Evas_Object *eo;
 233         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 234         if (eo) {
 235                 elm_win_title_set(eo, name);
 236                 evas_object_smart_callback_add(eo, "delete,request", _win_del,
 237                                                NULL);
 238         }
 239         CALC_FUN_END();
 240         return eo;
 241 }
 242
 243 /**
 244 * @describe
 245 *
 246 *
 247 * @param    ad
 248 * @return    void
 249 * @exception
 250 */
 251 static void _on_exit(struct appdata *ad)
 252 {
 253         CALC_FUN_BEG();
 254         if (ad->por_pannel) {
 255                 evas_object_del(ad->por_pannel);
 256                 ad->por_pannel = NULL;
 257         }
 258
 259         if (ad->lan_pannel) {
 260                 evas_object_del(ad->lan_pannel);
 261                 ad->lan_pannel = NULL;
 262         }
 263
 264         if (ad->input_entry) {
 265                 evas_object_del(ad->input_entry);
 266                 ad->input_entry = NULL;
 267         }
 268         if (ad->clear_item) {
 269                 elm_object_item_del(ad->clear_item);
 270                 ad->clear_item = NULL;
 271         }
 272         if (ad->more_btn_popup) {
 273                 evas_object_del(ad->more_btn_popup);
 274                 ad->more_btn_popup = NULL;
 275         }
 276         if (ad->more_btn) {
 277                 evas_object_del(ad->more_btn);
 278                 ad->more_btn = NULL;
 279         }
 280         if (ad->navi_it) {
 281                 elm_object_item_del(ad->navi_it);
 282                 ad->navi_it = NULL;
 283         }
 284
 285         if (ad->nf) {
 286                 evas_object_del(ad->nf);
 287                 ad->nf = NULL;
 288         }
 289          if (ad->window_icon) {
 290                 evas_object_del(ad->window_icon);
 291                 ad->window_icon = NULL;
 292         }
 293 #ifdef SAVE_HISTORY
 294         if (ad->hist_area) {
 295                 evas_object_del(ad->hist_area);
 296                 ad->hist_area = NULL;
 297         }
 298
 299         if (ad->hist_scroll) {
 300                 evas_object_del(ad->hist_scroll);
 301                 ad->hist_scroll = NULL;
 302         }
 303 #endif
 304
 305         if (ad->edje) {
 306                 evas_object_del(ad->edje);
 307                 ad->edje = NULL;
 308         }
 309
 310         if (ad->layout) {
 311                 evas_object_del(ad->layout);
 312                 ad->layout = NULL;
 313         }
 314
 315         if (ad->bg) {
 316                 evas_object_del(ad->bg);
 317                 ad->bg = NULL;
 318         }
 319
 320         if (ad->win) {
 321                 evas_object_del(ad->win);
 322                 ad->win = NULL;
 323         }
 324
 325         /* delete timer */
 326         if (ad->calc_timer) {
 327                 ecore_timer_del(ad->calc_timer);
 328                 ad->calc_timer = NULL;
 329         }
 330         if (ad->wrong_timer) {
 331                 ecore_timer_del(ad->wrong_timer);
 332                 ad->wrong_timer = NULL;
 333         }
 334
 335         feedback_deinitialize();
 336
 337         CALC_FUN_END();
 338 }
 339
 340 /**
 341 * @describe
 342 *
 343 *
 344 * @param    data
 345 * @return    int
 346 * @exception
 347 */
 348 static bool app_create(void *data)
 349 {
 350         CALC_FUN_BEG();
 351         struct appdata *ad = (struct appdata *)data;
 352
 353         /*  Use elm_theme_extension_add() API before creating any widgets */
 354         elm_theme_extension_add(NULL, CALCULATOR_THEME);
 355
 356         /* main widnow */
 357         ad->win = _create_win(PACKAGE);
 358         if (ad->win == NULL) {
 359                 return FALSE;
 360         }
 361         evas_object_smart_callback_add(ad->win, "profile,changed", win_profile_changed_cb, ad);
 362         evas_object_show(ad->win);
 363
 364         elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
 365
 366         /* will be removed */
 367         calc_xxx(ad);
 368
 369         /* load main view */
 370         calc_view_load(ad);
 371         ad->panel_show = EINA_TRUE;
 372
 373         int  value = 1;
 374         int ret = vconf_get_bool(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &value);
 375         if (ret == 0) {
 376                 if (value == 1) {
 377                         _rotate(APP_DEVICE_ORIENTATION_0, ad);
 378                 } else {
 379                         app_device_orientation_e curr = app_get_device_orientation();
 380                         _rotate(curr, ad);
 381                 }
 382         } else {
 383                 app_device_orientation_e curr = app_get_device_orientation();
 384                 _rotate(curr, ad);
 385         }
 386         /* register callback */
 387         ecore_idler_add((Ecore_Task_Cb) _set_input_entry_focus, ad);
 388         ecore_idler_add((Ecore_Task_Cb) _load_idle_view, ad);
 389         CALC_FUN_END();
 390         return TRUE;            //EXIT_SUCCESS
 391
 392 }
 393
 394 /**
 395 * @describe
 396 *
 397 *
 398 * @param    data
 399 * @return    int
 400 * @exception
 401 */
 402 static void app_terminate(void *data)
 403 {
 404         // Release all resources
 405         struct appdata *ad = (struct appdata *)data;
 406         _on_exit(ad);
 407 }
 408
 409 /**
 410 * @describe
 411 *
 412 *
 413 * @param    data
 414 * @return    int
 415 * @exception
 416 */
 417 static void app_pause(void *data)
 418 {
 419         // Take necessary actions when application becomes invisible
 420 }
 421
 422 /**
 423 * @describe
 424 *
 425 *
 426 * @param    data
 427 * @return    int
 428 * @exception
 429 */
 430 static void app_resume(void *data)
 431 {
 432         // Take necessary actions when application becomes visible.
 433         struct appdata *ad = (struct appdata *)data;
 434         elm_object_focus_set(ad->input_entry, EINA_TRUE);
 435 }
 436
 437 /**
 438 * @describe
 439 *   The entry of the program
 440 *
 441 * @param    argc
 442 * @param    argv
 443 * @param    int
 444 * @exception
 445 */
 446 int main(int argc, char *argv[])
 447 {
 448     CALC_FUN_BEG();
 449         struct appdata ad;
 450
 451         app_event_callback_s event_callback;
 452
 453         event_callback.create = app_create;
 454         event_callback.terminate = app_terminate;
 455         event_callback.pause = app_pause;
 456         event_callback.resume = app_resume;
 457         event_callback.service = NULL;
 458         event_callback.low_memory = NULL;
 459         event_callback.low_battery = NULL;
 460         event_callback.device_orientation = _rotate;
 461         event_callback.language_changed = NULL;
 462         event_callback.region_format_changed = NULL;
 463
 464         memset(&ad, 0x0, sizeof(struct appdata));
 465         CALC_FUN_END();
 466         return app_efl_main(&argc, &argv, &event_callback, &ad);
 467 }
 468