Пример #1
0
/* Function: al_play_sample
 */
bool al_play_sample(ALLEGRO_SAMPLE *spl, float gain, float pan, float speed,
   ALLEGRO_PLAYMODE loop, ALLEGRO_SAMPLE_ID *ret_id)
{
   static int next_id = 0;
   unsigned int i;
   
   ASSERT(spl);

   if (ret_id != NULL) {
      ret_id->_id = -1;
      ret_id->_index = 0;
   }

   for (i = 0; i < _al_vector_size(&auto_samples); i++) {
      ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&auto_samples, i);
      ALLEGRO_SAMPLE_INSTANCE *splinst = (*slot);

      if (!al_get_sample_instance_playing(splinst)) {
         int *id = _al_vector_ref(&auto_sample_ids, i);

         if (!do_play_sample(splinst, spl, gain, pan, speed, loop))
            break;

         if (ret_id != NULL) {
            ret_id->_index = (int) i;
            ret_id->_id = *id = ++next_id;
         }

         return true;
      }
   }

   return false;
}
Пример #2
0
/* Carefully destroy a menu item... If the item is part of a menu, it must be
 * removed from it.
 */
static void destroy_menu_item(ALLEGRO_MENU_ITEM *item)
{
   ASSERT(item);

   if (!item->parent) {
      /* This normally won't happen. */
      _al_destroy_menu_item_at(item, -1);
   }
   else {
      size_t i;
      for (i = 0; i < _al_vector_size(&item->parent->items); ++i) {
         if (*(ALLEGRO_MENU_ITEM **)_al_vector_ref(&item->parent->items, i) == item) {
            /* Notify the platform that the item is to be removed. */
            _al_destroy_menu_item_at(item, i);

            /* Remove the command from the look-up vector. */
            if (item->id != 0) {
               _AL_MENU_ID *menu_id;
               size_t j;

               for (j = 0; j < _al_vector_size(&menu_ids); ++j) {
                  menu_id = (_AL_MENU_ID *) _al_vector_ref(&menu_ids, j);
                  if (menu_id->menu == item->parent && menu_id->unique_id == item->unique_id) {
                     _al_vector_delete_at(&menu_ids, j);
                     break;
                  }
               }
            }

            /* Remove the menu from the parent's list. */
            _al_vector_delete_at(&item->parent->items, i);

            break;
         }
      }
   }

   if (item->caption)
      al_ustr_free(item->caption);

   if (item->popup) {
      /* Delete the sub-menu. Must set the parent/display to NULL ahead of time to
       * avoid recursing back here.
       */
      item->popup->parent = NULL;
      item->popup->display = NULL;
      al_destroy_menu(item->popup);
   }
   
   if (item->icon) {
      al_destroy_bitmap(item->icon);
   }

   al_free(item);
}
Пример #3
0
static void win_shutdown(void)
{
   ALLEGRO_SYSTEM *s;
   ALLEGRO_DISPLAY_INTERFACE *display_driver;
   ASSERT(vt);

   /* Close all open displays. */
   s = al_get_system_driver();
   while (_al_vector_size(&s->displays) > 0) {
      ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0);
      ALLEGRO_DISPLAY *d = *dptr;
      _al_destroy_display_bitmaps(d);
      al_destroy_display(d);
   }

   _al_vector_free(&s->displays);

   display_driver = vt->get_display_driver();
   if (display_driver && display_driver->shutdown) {
      display_driver->shutdown();
   }

   _al_win_shutdown_time();

   if (using_higher_res_timer) {
      timeEndPeriod(1);
   }

   al_free(vt);
   vt = NULL;

   ASSERT(_al_win_system);
   al_free(_al_win_system);
}
Пример #4
0
static void restore_mode_if_last_fullscreen_display(ALLEGRO_SYSTEM_XGLX *s,
   ALLEGRO_DISPLAY_XGLX *d)
{
   bool last_fullscreen = true;
   size_t i;

   /* If any other fullscreen display is still active on the same adapter,
    * we must not touch the video mode.
    */
   for (i = 0; i < s->system.displays._size; i++) {
      ALLEGRO_DISPLAY_XGLX **slot = _al_vector_ref(&s->system.displays, i);
      ALLEGRO_DISPLAY_XGLX *living = *slot;

      if (living == d)
         continue;

      /* Check for fullscreen displays on the same adapter. */
      if (living->adapter == d->adapter
            && (living->display.flags & ALLEGRO_FULLSCREEN)) {
         last_fullscreen = false;
      }
   }

   if (last_fullscreen) {
      ALLEGRO_DEBUG("restore mode.\n");
      _al_xglx_restore_video_mode(s, d->adapter);
   }
   else {
      ALLEGRO_DEBUG("*not* restoring mode.\n");
   }
}
Пример #5
0
/* ljoy_get_joystick: [primary thread]
 *
 *  Returns the address of a ALLEGRO_JOYSTICK structure for the device
 *  number NUM.
 */
static ALLEGRO_JOYSTICK *ljoy_get_joystick(int num)
{
    ALLEGRO_JOYSTICK *ret = NULL;
    unsigned i;
    ASSERT(num >= 0);

    al_lock_mutex(config_mutex);

    for (i = 0; i < _al_vector_size(&joysticks); i++) {
        ALLEGRO_JOYSTICK_LINUX **slot = _al_vector_ref(&joysticks, i);
        ALLEGRO_JOYSTICK_LINUX *joy = *slot;

        if (ACTIVE_STATE(joy->config_state)) {
            if (num == 0) {
                ret = (ALLEGRO_JOYSTICK *)joy;
                break;
            }
            num--;
        }
    }

    al_unlock_mutex(config_mutex);

    return ret;
}
void _al_xwin_destroy_mouse_cursor(ALLEGRO_MOUSE_CURSOR *cursor)
{
   ALLEGRO_MOUSE_CURSOR_XGLX *xcursor = (ALLEGRO_MOUSE_CURSOR_XGLX *)cursor;
   ALLEGRO_SYSTEM *sys = al_get_system_driver();
   ALLEGRO_SYSTEM_XGLX *sysx = (ALLEGRO_SYSTEM_XGLX *)sys;
   unsigned i;

   _al_mutex_lock(&sysx->lock);

   for (i = 0; i < _al_vector_size(&sys->displays); i++) {
      ALLEGRO_DISPLAY_XGLX **slot = _al_vector_ref(&sys->displays, i);
      ALLEGRO_DISPLAY_XGLX *glx = *slot;

      if (glx->current_cursor == xcursor->cursor) {
         if (!glx->cursor_hidden)
            XUndefineCursor(sysx->x11display, glx->window);
         glx->current_cursor = None;
      }
   }

   XFreeCursor(sysx->x11display, xcursor->cursor);
   al_free(xcursor);

   _al_mutex_unlock(&sysx->lock);
}
Пример #7
0
/* Function: al_stop_sample
 */
void al_stop_sample(ALLEGRO_SAMPLE_ID *spl_id)
{
   int *id;

   ASSERT(spl_id->_id != -1);
   ASSERT(spl_id->_index < (int) _al_vector_size(&auto_samples));
   ASSERT(spl_id->_index < (int) _al_vector_size(&auto_sample_ids));

   id = _al_vector_ref(&auto_sample_ids, spl_id->_index);
   if (*id == spl_id->_id) {
      ALLEGRO_SAMPLE_INSTANCE **slot, *spl;
      slot = _al_vector_ref(&auto_samples, spl_id->_index);
      spl = (*slot);
      al_stop_sample_instance(spl);
   }
}
Пример #8
0
/*
 * Must be called before the D3D device is reset (e.g., when
 * resizing a window). All non-synced display bitmaps must be
 * synced to memory.
 */
void _al_d3d_prepare_bitmaps_for_reset(ALLEGRO_DISPLAY_D3D *disp)
{
   unsigned int i;

   if (disp->device_lost)
      return;

   if (!_al_d3d_render_to_texture_supported())
      return;

   al_lock_mutex(_al_d3d_lost_device_mutex);

   for (i = 0; i < created_bitmaps._size; i++) {
      ALLEGRO_BITMAP_D3D **bptr = (ALLEGRO_BITMAP_D3D **)_al_vector_ref(&created_bitmaps, i);
      ALLEGRO_BITMAP_D3D *bmp = *bptr;
      ALLEGRO_BITMAP *al_bmp = (ALLEGRO_BITMAP *)bmp;
      if (bmp->display == disp) {
         //d3d_sync_bitmap_memory(al_bmp);
         if (!al_bmp->preserve_texture) {
            bmp->modified = false;
         }
         else if (!bmp->is_backbuffer && bmp->modified && !(al_bmp->flags & ALLEGRO_MEMORY_BITMAP)) {
            _al_d3d_sync_bitmap(al_bmp);
            bmp->modified = false;
         }
      }
   }

   al_unlock_mutex(_al_d3d_lost_device_mutex);
}
Пример #9
0
/*
 * Refresh the texture memory. This must be done after a device is
 * lost or after it is reset.
 */
void _al_d3d_refresh_texture_memory(void)
{
   unsigned int i;

   for (i = 0; i < created_bitmaps._size; i++) {
      ALLEGRO_BITMAP_D3D **bptr = (ALLEGRO_BITMAP_D3D **)_al_vector_ref(&created_bitmaps, i);
      ALLEGRO_BITMAP_D3D *bmp = *bptr;
      ALLEGRO_BITMAP *al_bmp = (ALLEGRO_BITMAP *)bmp;
      ALLEGRO_DISPLAY_D3D *bmps_display = (ALLEGRO_DISPLAY_D3D *)al_bmp->display;

      if ((al_bmp->flags & ALLEGRO_MEMORY_BITMAP) || (al_bmp->parent)) {
         continue;
      }

      d3d_create_textures(bmps_display, bmp->texture_w, bmp->texture_h,
         al_bmp->flags,
	 &bmp->video_texture, /*&bmp->system_texture*/0, al_bmp->format);
      d3d_sync_bitmap_texture(al_bmp,
	 0, 0, al_bmp->w, al_bmp->h);
      if (_al_d3d_render_to_texture_supported()) {
	 bmps_display->device->UpdateTexture(
	    (IDirect3DBaseTexture9 *)bmp->system_texture,
	    (IDirect3DBaseTexture9 *)bmp->video_texture);
      }
   }
}
Пример #10
0
static void win_shutdown(void)
{
    ALLEGRO_SYSTEM *s;
    ASSERT(vt);

    /* Close all open displays. */
    s = al_get_system_driver();
    while (_al_vector_size(&s->displays) > 0) {
        ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->displays, 0);
        ALLEGRO_DISPLAY *d = *dptr;
        al_destroy_display(d);
    }

    _al_vector_free(&s->displays);

#ifdef ALLEGRO_CFG_D3D
    _al_d3d_shutdown_display();
#endif

    _al_win_shutdown_time();

    if (using_higher_res_timer) {
        timeEndPeriod(1);
    }

    al_free(vt);
    vt = NULL;

    ASSERT(_al_win_system);
    al_free(_al_win_system);
}
Пример #11
0
static void ljoy_merge(void)
{
    unsigned i;

    config_needs_merging = false;
    num_joysticks = 0;

    for (i = 0; i < _al_vector_size(&joysticks); i++) {
        ALLEGRO_JOYSTICK_LINUX **slot = _al_vector_ref(&joysticks, i);
        ALLEGRO_JOYSTICK_LINUX *joy = *slot;

        switch (joy->config_state) {
        case LJOY_STATE_UNUSED:
            break;

        case LJOY_STATE_BORN:
        case LJOY_STATE_ALIVE:
            joy->config_state = LJOY_STATE_ALIVE;
            num_joysticks++;
            break;

        case LJOY_STATE_DYING:
            inactivate_joy(joy);
            break;
        }
    }

    ALLEGRO_DEBUG("Merge done, num_joysticks=%d\n", num_joysticks);
}
Пример #12
0
/* Function: al_find_menu
 */
ALLEGRO_MENU *al_find_menu(ALLEGRO_MENU *haystack, uint16_t id)
{
   int index;

   return !al_find_menu_item(haystack, id, &haystack, &index) ? NULL :
      (*(ALLEGRO_MENU_ITEM **)_al_vector_ref(&haystack->items, index))->popup;
}
Пример #13
0
/* ljoy_exit_joystick: [primary thread]
 *  Shut down the joystick driver.
 */
static void ljoy_exit_joystick(void)
{
    int i;

#ifdef SUPPORT_HOTPLUG
    if (inotify_fd != -1) {
        _al_unix_stop_watching_fd(inotify_fd);
        close(inotify_fd);
        inotify_fd = -1;
    }
    hotplug_ended = true;
    al_signal_cond(hotplug_cond);
    al_join_thread(hotplug_thread, NULL);
#endif

    al_destroy_mutex(config_mutex);
    config_mutex = NULL;

    for (i = 0; i < (int)_al_vector_size(&joysticks); i++) {
        ALLEGRO_JOYSTICK_LINUX **slot = _al_vector_ref(&joysticks, i);
        inactivate_joy(*slot);
        al_free(*slot);
    }
    _al_vector_free(&joysticks);
    num_joysticks = 0;
}
Пример #14
0
static bool init_touch_input(void)
{
   unsigned i;
   ALLEGRO_SYSTEM* system;

   if (installed)
      return false;

   if (!_al_win_init_touch_input_api())
      return false;

   memset(&touch_input_state, 0, sizeof(touch_input_state));

   _al_event_source_init(&touch_input.es);
   _al_event_source_init(&touch_input.mouse_emulation_es);

   touch_input.mouse_emulation_mode = ALLEGRO_MOUSE_EMULATION_TRANSPARENT;

   installed = true;

   system = al_get_system_driver();
   for (i = 0; i < _al_vector_size(&system->displays); ++i) {
      bool r;
      ALLEGRO_DISPLAY_WIN *win_display = *((ALLEGRO_DISPLAY_WIN**)_al_vector_ref(&system->displays, i));
      r = _al_win_register_touch_window(win_display->window, 0);
	  ALLEGRO_INFO("registering touch window %p: %d\n", win_display, r);
	  if (!r) {
		 ALLEGRO_ERROR("RegisterTouchWindow failed: %s\n", get_error_desc(GetLastError()));
	     return false;
	  }
   }

   return true;
}
Пример #15
0
/* Look through all the bitmaps associated with all the shaders and c;ear their
 * shader field */
void _al_glsl_unuse_shaders(void)
{
   unsigned i;
   al_lock_mutex(shaders_mutex);
   for (i = 0; i < _al_vector_size(&shaders); i++) {
      unsigned j;
      ALLEGRO_SHADER *shader = *((ALLEGRO_SHADER **)_al_vector_ref(&shaders, i));

      for (j = 0; j < _al_vector_size(&shader->bitmaps); j++) {
         ALLEGRO_BITMAP *bitmap =
            *((ALLEGRO_BITMAP **)_al_vector_ref(&shader->bitmaps, j));
         _al_set_bitmap_shader_field(bitmap, NULL);
      }
   }
   al_unlock_mutex(shaders_mutex);
}
/* stream_free:
 *  This function is ALLEGRO_MIXER aware and frees the memory associated with
 *  the sample or mixer, and detaches any attached streams or mixers.
 */
static void stream_free(ALLEGRO_SAMPLE_INSTANCE *spl)
{
   if (spl) {
      /* Make sure we free the mixer buffer and de-reference the attached
       * streams if this is a mixer stream.
       */
      if (spl->is_mixer) {
         ALLEGRO_MIXER *mixer = (ALLEGRO_MIXER *)spl;
         int i;

         _al_kcm_stream_set_mutex(&mixer->ss, NULL);

         for (i = _al_vector_size(&mixer->streams) - 1; i >= 0; i--) {
            ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&mixer->streams, i);
            ALLEGRO_SAMPLE_INSTANCE *spl = *slot;
            spl->parent.u.ptr = NULL;
         }

         _al_vector_free(&mixer->streams);

         if (spl->spl_data.buffer.ptr) {
            ASSERT(spl->spl_data.free_buf);
            al_free(spl->spl_data.buffer.ptr);
            spl->spl_data.buffer.ptr = NULL;
         }
         spl->spl_data.free_buf = false;
      }

      ASSERT(! spl->spl_data.free_buf);

      al_free(spl);
   }
}
Пример #17
0
void _al_d3d_destroy_display_format_list(void)
{
   /* Free the display format list */
   for (int j = 0; j < (int)_al_vector_size(&eds_list); j++) {
      void **eds = (void **)_al_vector_ref(&eds_list, j);
      al_free(*eds);
   }
   _al_vector_free(&eds_list);
}
Пример #18
0
/* Function: al_stop_samples
 */
void al_stop_samples(void)
{
   unsigned int i;

   for (i = 0; i < _al_vector_size(&auto_samples); i++) {
      ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&auto_samples, i);
      ALLEGRO_SAMPLE_INSTANCE *spl = (*slot);
      al_stop_sample_instance(spl);
   }
}
Пример #19
0
/* [gtk thread] */
static void build_menu(GtkWidget *gmenu, ALLEGRO_MENU *amenu)
{
   size_t i;
   
   for (i = 0; i < _al_vector_size(&amenu->items); ++i) {
      ALLEGRO_MENU_ITEM *aitem = * (ALLEGRO_MENU_ITEM **) _al_vector_ref(&amenu->items, i);
      GtkWidget *gitem = build_menu_item(aitem);
      gtk_menu_shell_append(GTK_MENU_SHELL(gmenu), gitem);
   }
}
Пример #20
0
/* Destroy all sample instances, and frees the associated vectors. */
static void free_sample_vector(void)
{
   int j;

   for (j = 0; j < (int) _al_vector_size(&auto_samples); j++) {
      ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&auto_samples, j);
      al_destroy_sample_instance(*slot);
   }
   _al_vector_free(&auto_samples);
   _al_vector_free(&auto_sample_ids);
}
/* joydx_exit_joystick: [primary thread]
 *  Shuts down the DirectInput joystick devices.
 */
static void joydx_exit_joystick(void)
{
   int i;
   ALLEGRO_SYSTEM *system;
   size_t j;

   ALLEGRO_DEBUG("Entering joydx_exit_joystick\n");

   ASSERT(joydx_thread);

   /* stop the thread */
   SetEvent(STOP_EVENT);
   WaitForSingleObject(joydx_thread, INFINITE);
   CloseHandle(joydx_thread);
   joydx_thread = NULL;

   /* free thread resources */
   CloseHandle(STOP_EVENT);
   STOP_EVENT = NULL;
   DeleteCriticalSection(&joydx_thread_cs);

   /* The toplevel display is assumed to have the input acquired. Release it. */
   system = al_get_system_driver();
   for (j = 0; j < _al_vector_size(&system->displays); j++) {
      ALLEGRO_DISPLAY_WIN **pwin_disp = _al_vector_ref(&system->displays, j);
      ALLEGRO_DISPLAY_WIN *win_disp = *pwin_disp;
      if (win_disp->window == GetForegroundWindow()) {
         ALLEGRO_DEBUG("Requesting window unacquire joystick devices\n");
         _al_win_wnd_call_proc(win_disp->window,
                               _al_win_joystick_dinput_unacquire,
                               win_disp);
      }
   }

   /* destroy the devices */
   for (i = 0; i < MAX_JOYSTICKS; i++) {
      joydx_inactivate_joy(&joydx_joystick[i]);
   }
   joydx_num_joysticks = 0;

   for (i = 0; i < MAX_JOYSTICKS; i++) {
      JOYSTICK_WAKER(i) = NULL;
   }

   /* destroy the DirectInput interface */
   IDirectInput8_Release(joystick_dinput);
   joystick_dinput = NULL;

   /* release module handle */
   FreeLibrary(_al_dinput_module);
   _al_dinput_module = NULL;

   ALLEGRO_DEBUG("Leaving joydx_exit_joystick\n");
}
Пример #22
0
void _al_d3d_score_display_settings(ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref)
{
   for (int i = 0; i < (int)_al_vector_size(&eds_list); i++) {
      ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds, **peds;
      peds = (ALLEGRO_EXTRA_DISPLAY_SETTINGS **)_al_vector_ref(&eds_list, i);
      eds = *peds;
      eds->score = _al_score_display_settings(eds, ref);
      eds->index = i;
   }

   qsort(eds_list._items, eds_list._size, eds_list._itemsize, _al_display_settings_sorter);
}
Пример #23
0
ALLEGRO_DISPLAY *_al_sdl_find_display(uint32_t window_id) {
   unsigned int i;
   ALLEGRO_SYSTEM *s = al_get_system_driver();
   for (i = 0; i < _al_vector_size(&s->displays); i++) {
      void **v = (void **)_al_vector_ref(&s->displays, i);
      ALLEGRO_DISPLAY_SDL *d = *v;
      if (SDL_GetWindowID(d->window) == window_id) {
         return &d->display;
         break;
      }
   }
   return NULL;
}
Пример #24
0
/* Function: al_backup_dirty_bitmaps
 */
void al_backup_dirty_bitmaps(ALLEGRO_DISPLAY *display)
{
   unsigned int i;

   for (i = 0; i < display->bitmaps._size; i++) {
      ALLEGRO_BITMAP **bptr = (ALLEGRO_BITMAP **)_al_vector_ref(&display->bitmaps, i);
      ALLEGRO_BITMAP *bmp = *bptr;
      if (_al_get_bitmap_display(bmp) == display) {
         if (bmp->vt && bmp->vt->backup_dirty_bitmap) {
            bmp->vt->backup_dirty_bitmap(bmp);
	 }
      }
   }
}
Пример #25
0
static void transfer_display_bitmaps_to_any_other_display(
   ALLEGRO_SYSTEM_XGLX *s, ALLEGRO_DISPLAY *d)
{
   size_t i;
   ALLEGRO_DISPLAY *living = NULL;
   ASSERT(s->system.displays._size > 1);

   for (i = 0; i < s->system.displays._size; i++) {
      ALLEGRO_DISPLAY **slot = _al_vector_ref(&s->system.displays, i);
      living = *slot;
      if (living != d)
         break;
   }

   ALLEGRO_DEBUG("transferring display bitmaps to other display.\n");

   for (i = 0; i < d->bitmaps._size; i++) {
      ALLEGRO_BITMAP **add = _al_vector_alloc_back(&(living->bitmaps));
      ALLEGRO_BITMAP **ref = _al_vector_ref(&d->bitmaps, i);
      *add = *ref;
      (*add)->_display = living;
   }
}
Пример #26
0
/* Function: al_set_default_mixer
 */
bool al_set_default_mixer(ALLEGRO_MIXER *mixer)
{
   ASSERT(mixer != NULL);

   if (mixer != default_mixer) {
      int i;

      default_mixer = mixer;

      /* Destroy all current sample instances, recreate them, and
       * attach them to the new mixer */
      for (i = 0; i < (int) _al_vector_size(&auto_samples); i++) {
         ALLEGRO_SAMPLE_INSTANCE **slot = _al_vector_ref(&auto_samples, i);
         int *id = _al_vector_ref(&auto_sample_ids, i);

         *id = 0;
         al_destroy_sample_instance(*slot);

         *slot = al_create_sample_instance(NULL);
         if (!*slot) {
            ALLEGRO_ERROR("al_create_sample failed\n");
            goto Error;
         }
         if (!al_attach_sample_instance_to_mixer(*slot, default_mixer)) {
            ALLEGRO_ERROR("al_attach_mixer_to_sample failed\n");
            goto Error;
         }
      }      
   }

   return true;

Error:
   free_sample_vector();
   default_mixer = NULL;   
   return false;
}
Пример #27
0
/* Function: al_get_display_menu
 */
ALLEGRO_MENU *al_get_display_menu(ALLEGRO_DISPLAY *display)
{
   size_t i;
   ASSERT(display);
   
   /* Search through the display_menus vector to see if this display has
    * a menu associated with it. */
   for (i = 0; i < _al_vector_size(&display_menus); ++i) {
      DISPLAY_MENU *dm = (DISPLAY_MENU *) _al_vector_ref(&display_menus, i);
      if (dm->display == display)
         return dm->menu;
   }

   return NULL;
}
Пример #28
0
/* All public functions that take a menu and id parameter have two interpretations:
 *
 *   1) If id > 0, then it represents an id anywhere within the menu structure, 
 *   including child menus. If there are non-unique IDs, the first one found is
 *   returned, but the exact order is undefined. (IDs are meant to be unique.)
 *
 *   2) If id <= 0, then its absolute value represents an ordered index for that
 *   exact menu. 
 *
 * If the parameters are valid, it returns a pointer to the corresponding 
 * MENU_ITEM, and the menu/id parameters are set to the item's parent and its
 * index. Otherwise (on invalid parameters), it returns NULL and the menu/id
 * parameters are left undefined.
 *
 * (Note that the private OS specific functions always take a direct index.)
 */
static ALLEGRO_MENU_ITEM *interpret_menu_id_param(ALLEGRO_MENU **menu, int *id)
{
   if (*id > 0) {
      if (!al_find_menu_item(*menu, *id, menu, id))
         return NULL;
   }
   else {
      *id = (0 - *id);

      if ((size_t) *id >= _al_vector_size(&((*menu)->items)))
         return NULL;
   }

   return *(ALLEGRO_MENU_ITEM **) _al_vector_ref(&((*menu)->items), (size_t) *id);   
}  
Пример #29
0
static ALLEGRO_JOYSTICK_LINUX *ljoy_by_device_name(
    const ALLEGRO_USTR *device_name)
{
    unsigned i;

    for (i = 0; i < _al_vector_size(&joysticks); i++) {
        ALLEGRO_JOYSTICK_LINUX **slot = _al_vector_ref(&joysticks, i);
        ALLEGRO_JOYSTICK_LINUX *joy = *slot;

        if (joy && al_ustr_equal(device_name, joy->device_name))
            return joy;
    }

    return NULL;
}
/* Internal function: _al_foreach_destructor
 *  Call the callback for each registered object.
 *  [thread-safe]
 */
void _al_foreach_destructor(_AL_DTOR_LIST *dtors,
   void (*callback)(void *object, void (*func)(void *), void *udata),
   void *userdata)
{
   _al_mutex_lock(&dtors->mutex);
   {
      unsigned int i;

      for (i = 0; i < _al_vector_size(&dtors->dtors); i++) {
         DTOR *dtor = _al_vector_ref(&dtors->dtors, i);
         callback(dtor->object, dtor->func, userdata);
      }
   }
   _al_mutex_unlock(&dtors->mutex);
}