def adjust_preamp(self, widget):
     """
     Adjust the preamp
     """
     if widget.get_value() != settings.get_option("plugin/equalizer/pre"):
         settings.set_option("plugin/equalizer/pre", widget.get_value())
         self.combo_presets.set_active(0)

def __autoconfig():
    '''
        If the user hasn't used our plugin before, then try to
        autoconfig their audio settings to use a different audio
        device if possible.. 
        
        TODO: It would be cool if we could notify the user that
        a new device was plugged in...
    '''
    
    from xl import settings

    if settings.get_option('preview_device/audiosink', None) is not None:
        return
        
    sink = settings.get_option('player/audiosink', None)    
    if sink is None:
        return
        
    settings.set_option( 'preview_device/audiosink', sink )
    
    main_device = settings.get_option('player/audiosink_device', None)
    if main_device is None:
        return
    
    from xl.player import pipe
    devices = pipe.sink_enumerate_devices(sink)
    if devices is not None:
        # pick the first one that isn't the main device and isn't 'Auto'
        # -> if the main device is '', then it's auto. So... we actually
        # iterate backwards, assuming that the ordering matters
        for device,name in reversed(devices):
            if device != main_device and name != _('Auto'):
                settings.set_option( 'preview_device/audiosink_device', device )
                break

 def LoopStatus(self, value):
     playlist = QUEUE.current_playlist
     if hasattr(playlist, "set_repeat"):
         # <= 0.3.2
         if value == 'Playlist':
             enabled, mode = True, 'playlist'
         elif value == 'Track':
             enabled, mode = True, 'track'
         else:
             enabled, mode = False, 'none'
         logger.debug("LoopStatus set: old, %r, %r" % (enabled, mode))
         playlist.set_repeat(enabled, mode)
         settings.set_option('playback/repeat', enabled)
         if enabled:
             settings.set_option('playback/repeat_mode', mode)
     else:
         # >= 0.3.3
         if value == 'Playlist':
             mode = 'all'
         elif value == 'Track':
             mode = 'track'
         else:
             mode = 'disabled'
         logger.debug("LoopStatus set: new, %r" % mode)
         playlist.set_repeat_mode(mode)

 def on_playlist_utilities_bar_visible_toggled(self, checkmenuitem):
     """
         Shows or hides the playlist utilities bar
     """
     settings.set_option(
         'gui/playlist_utilities_bar_visible', checkmenuitem.get_active()
     )

    def _destroy_gui_hooks(self):
        '''
            Removes any hooks from the main Exaile GUI
        '''

        if not self.hooked:
            return

        info_area = main.mainwindow().info_area
        play_toolbar = main.mainwindow().builder.get_object('play_toolbar')

        # detach main GUI elements
        parent = play_toolbar.get_parent()
        parent.remove(play_toolbar)

        parent = info_area.get_parent()
        parent.remove(info_area)

        # detach the element we added to hold them
        parent = self.pane.get_parent()
        parent.remove(self.pane)

        # reattach
        parent.pack_start(info_area, False, False, 0)
        parent.reorder_child(info_area, 0)
        parent.pack_start(play_toolbar, False, False, 0)

        # remove player events
        self._setup_events(event.remove_callback)

        self.hooked = False
        settings.set_option('plugin/previewdevice/shown', False)
        logger.debug('Preview device unhooked')

 def set_column_width(self, col, stuff=None):
     """
         Called when the user resizes a column
     """
     name = {self.colname: 'filename', self.colsize: 'size'}[col]
     name = "gui/files_%s_col_width" % name
     settings.set_option(name, col.get_width(), save=False)

 def save_panel_settings(self):
     
     if self.loading_panels:
         return
     
     param = dict([(k, v.opts) for k, v in self.panels.iteritems()])
     settings.set_option('gui/panels', param)

def migrate():
    """
        Migrate normal/unified engine users to gstreamer
    """
    engine = settings.get_option('player/engine', None)
    if engine in ['normal', 'unified']:
        settings.set_option('player/engine', 'gstreamer')

    def apply(self, value=None):
        """
            Applies this setting
        """
        if not self.done():
            return False

        if value is None:
            value = self._get_value()
        if value is None:
            return True

        if value != '':
            hashfunc = hashlib.new(self.type)
            hashfunc.update(value)
            value = hashfunc.hexdigest()

        oldvalue = settings.get_option(self.name, self.default)

        if value != oldvalue:
            settings.set_option(self.name, value)

        self.widget.set_text(value)
        self.widget.set_visibility(True)
        self._delete_text_id = self.widget.connect('delete-text', self.on_delete_text)
        self._insert_text_id = self.widget.connect('insert-text', self.on_insert_text)

        return True

 def adjust_preamp(self, widget, data):
     """
     Adjust the preamp
     """
     if widget.get_value() != settings.get_option("plugin/equalizer/pre"):
         settings.set_option("plugin/equalizer/pre", widget.get_value())
         self.ui.get_object("combo-presets").set_active(0)

 def engine_notify_user_volume_change(self, vol):
     '''
         Engine calls this when something inside the engine changes
         the user volume.
         
         .. note:: Only to be called from engine
     '''
     settings.set_option('%s/volume' % self._name, vol)

    def VolumeSet(self, volume):
        """
            Sets the volume, arument in the range [0, 100]
        """
        if volume < 0 or volume > 100:
            pass

        settings.set_option('player/volume', volume / 100)

 def on_sizing_item_activate(menu_item, name, parent, context):
     """
         Updates column sizing setting
     """
     if name == 'resizable':
         settings.set_option('gui/resizable_cols', True)
     elif name == 'autosize':
         settings.set_option('gui/resizable_cols', False)

 def winclose(self,*arg):
     settings.set_option('plugin/LyricDisp/windowpositionx', self.window.get_position()[0])
     settings.set_option('plugin/LyricDisp/windowpositiony', self.window.get_position()[1])
     global TIMER, PLUGIN
     try:gobject.source_remove(TIMER)
     except:pass
     PLUGIN = None
     return False

    def window_state_change_event(self, window, event):
        """
            Saves the current maximized and fullscreen
            states and minimizes to tray if requested
        """
        if event.changed_mask & gtk.gdk.WINDOW_STATE_MAXIMIZED:
            settings.set_option("gui/mainw_maximized", bool(event.new_window_state & gtk.gdk.WINDOW_STATE_MAXIMIZED))
        if event.changed_mask & gtk.gdk.WINDOW_STATE_FULLSCREEN:
            self._fullscreen = bool(event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN)

        # detect minimization state changes
        prev_minimized = self.minimized

        if not self.minimized:

            if (
                event.changed_mask & gtk.gdk.WINDOW_STATE_ICONIFIED
                and not event.changed_mask & gtk.gdk.WINDOW_STATE_WITHDRAWN
                and event.new_window_state & gtk.gdk.WINDOW_STATE_ICONIFIED
                and not event.new_window_state & gtk.gdk.WINDOW_STATE_WITHDRAWN
                and not self.window_state & gtk.gdk.WINDOW_STATE_ICONIFIED
            ):

                self.minimized = True
        else:
            if event.changed_mask & gtk.gdk.WINDOW_STATE_WITHDRAWN and not event.new_window_state & (
                gtk.gdk.WINDOW_STATE_WITHDRAWN
            ):  # and \

                self.minimized = False

        # track this
        self.window_state = event.new_window_state

        if settings.get_option("gui/minimize_to_tray", False):

            # old code to detect minimization
            # -> it must have worked at some point, perhaps this is a GTK version
            # specific set of behaviors? Current code works now on 2.24.17

            # if wm_state is not None:
            #    if '_NET_WM_STATE_HIDDEN' in wm_state[2]:
            #        show tray
            #        window.hide
            # else
            #    destroy tray

            if self.minimized != prev_minimized and self.minimized == True:
                if not settings.get_option("gui/use_tray", False) and self.controller.tray_icon is None:
                    self.controller.tray_icon = tray.TrayIcon(self)

                window.hide()
            elif window.window.property_get("_NET_WM_STATE") is None:
                if not settings.get_option("gui/use_tray", False) and self.controller.tray_icon is not None:
                    self.controller.tray_icon.destroy()
                    self.controller.tray_icon = None

        return False

 def teardown(self, exaile):
     '''Called when exaile is exiting'''
     
     if settings.get_option('plugin/history/save_on_exit', history_preferences.save_on_exit_default ):
         self.history_playlist.save_to_location( self.history_loc )
         settings.set_option( 'plugin/history/shown', self.is_shown() )
     else:
         settings.set_option( 'plugin/history/shown', False )
         
     self.show_history(False)

def migrate():
    """
        Enables the OSD plugin if the builtin OSD was originally enabled
    """
    plugins = settings.get_option('plugins/enabled', [])

    if settings.get_option('osd/enabled', False) and 'osd' not in plugins:
        settings.set_option('plugins/enabled', plugins + ['osd'])

    settings.set_option('osd/enabled', False)

    def test_cuts_cb(self):
        value = []
        settings.set_option("collection/strip_list", value)
        track.Track._the_cuts_cb(None, None, "collection/strip_list")
        self.assertEqual(track.Track._Track__the_cuts, value)

        value = ["the", "foo"]
        settings.set_option("collection/strip_list", value)
        track.Track._the_cuts_cb(None, None, "collection/strip_list")
        self.assertEqual(track.Track._Track__the_cuts, value)

    def do_configure_event(self, e):
        """
            Stores the window size
        """
        width, height = self.get_size()

        settings.set_option('plugin/osd/width', width)
        settings.set_option('plugin/osd/height', height)

        Gtk.Window.do_configure_event(self, e)

    def set_volume(self, volume):
        """
            Sets the current user volume

            :param volume: the volume percentage
            :type volume: int
        """
        volume = min(volume, 100)
        volume = max(0, volume)
        settings.set_option("%s/volume" % self._name, volume / 100.0)