I’m talking about instant preview, the snapshot of a given search result that pops up when you hover the mouse over it, or click the magnifying glass next to it. I didn’t mind the instant search feature they rolled out earlier this year. I used it for a couple of weeks until the constant screen updates as I edited the search box got annoying. And then I simply turned it off. For instant preview it’s not so simple. Oh you can sort of turn it off by closing the popup box, but as soon as you (inadvertently) click the screen near a search result, the popup returns.

I did some cursory searching and lots of people don’t like this feature, and they all wanted to know how to turn it off permanently. Google apparently hasn’t given users a clear way to do that, which makes me wonder what the heck is going on over there. First there was the Buzz lawsuit, and now search features you can’t disable. It’s a bad scene.

But there is hope if you are a Firefox user and have AdBlock Plus installed. You can add these three filters to stop instant preview for good:

google.com##.vspi
google.com##.vspib
google.com###vspb

They are working well so far. I shudder to think what new stuff is in the works.

You would think such a thing would be common and therefore it would be easy to deduce how to do it in InstallShield. Well, yes and no. After some web searching that didn’t get me very far, I was browsing around the Dialogs view in InstallShield 2010 and noticed that in the Behavior section for my custom dialog were three tabs at the bottom of the screen. They were labeled Events, Subscriptions, and Conditions, and though they didn’t *look* like tabs that is what they were. It turns out the Conditions tab was what I was after. From there I could specify the Hide action on my controls when a certain MSI property had a specific value. Not terribly intuitive, but I did find it eventually.

The trick will be remembering how I did it a year from now if I’m asked to modify the installer like that again.

My first and so far only attempt was a simple hosting application that had a single page with an iframe. Inside that iframe I loaded the XBAP file that referred to my WinForm app. The only real tricky part was retrofitting the app to be able to mostly do its thing in a restricted environment. But still, I’m fairly impressed that Microsoft makes this possible. It seems I should pay closer attention to WPF and what it can do.

I like the idea of an ultra-small laptop that is used primarily for running applications over the Internet. When I was shopping for a laptop last summer, I checked out the current crop of netbooks and seriously considered going in that direction. The problem is devices that size have limitations, which eventually made me go with a traditional, albeit small, laptop.

The biggest issues for me with netbooks are the too-small screen and the fact that they are still somewhat underpowered. I know the early EE, Dell, and Acer machines had screens around 10 inches. I guess Acer is now making one that’s slightly above 11, but that’s still tiny. I was afraid I’d be squinting to see details.

The Intel Atom seemed very cool, but I wanted the ability to run some heavyweight local applications if desired (think Visual Studio), and I worried the system would end up having sub-optimal performance. I hadn’t heard about Intel’s newest netbook CPUs, but dual-core certainly is an improvement. Still, for only a slightly larger form factor, I got a 2.6 GHz Core 2 Duo in my Dell Latitude.

As small as they are, they still aren’t as easy to take with you as a smartphone. Jeff considered having an inexpensive netbook and access to the Internet, without being chained to a wireless provider, to be a boon to computer users everywhere. But since wireless hotspots don’t exist everywhere yet, I don’t see how you can truly have the freedom to access the Internet wherever you want without going through one of the big wireless providers. I’ve been in lots of places without a hotspot but that did have T-mobile coverage, and I’ve often wished I had a broadband modem to connect.

Even though they are neat computers, truly, they aren’t going to be for everyone.

It was still under warranty so I called Dell and figured I’d have to take it some place local or they would send a technician. Much to my surprise, they said I would be sent a new keyboard assembly and I could replace it myself. I have no problem with swapping out hardware components, I was just surprised that doing so has gotten so easy. Back in the day it could be a serious pain in the neck to replace certain parts on a laptop.

They had an online manual for removing the keyboard assembly and installing a new one. It took all of 2 minutes, and the new keyboard works great.

So thank you Dell, for making module parts that are easy to replace.

Version 1.2 for Visual Studio 2005 was OK, but wasn’t as easy to work with as the superior version 1.3 for Visual Studio 2008. I haven’t seen any of the betas for Visual Studio 2010, but I’m hoping the built-in SharePoint tools they’ve created will be even easier to use.

I had not written any WMI-related code up til now, simply because I’ve always been able to find other methods to get the information I need. But after reading that post and knowing of a particular program of mine that does access the registry directly to determine the start mode for a service, I decided to re-write that code to use WMI via the System.Management namespace in the .NET framework.

I came across a couple of different C# samples on the web and was able to modify them to fit my needs. Below is a new class I created for service management that will hopefully grow over time.

Imports System.Management

Public Class ServiceManagement
    'Enumeration of service startup modes
    Public Enum ServiceStartMode
        Boot = 0
        System = 1
        Automatic = 2
        Manual = 3
        Disabled = 4
    End Enum

    'Return values for service-related WMI routines
    Public Enum ReturnValue
        Success = 0
        NotSupported = 1
        AccessDenied = 2
        DependentServicesRunning = 3
        InvalidServiceControl = 4
        ServiceCannotAcceptControl = 5
        ServiceNotActive = 6
        ServiceRequestTimeout = 7
        UnknownFailure = 8
        PathNotFound = 9
        ServiceAlreadyRunning = 10
        ServiceDatabaseLocked = 11
        ServiceDependencyDeleted = 12
        ServiceDependencyFailure = 13
        ServiceDisabled = 14
        ServiceLogonFailure = 15
        ServiceMarkedForDeletion = 16
        ServiceNoThread = 17
        StatusCircularDependency = 18
        StatusDuplicateName = 19
        StatusInvalidName = 20
        StatusInvalidParameter = 21
        StatusInvalidServiceAccount = 22
        StatusServiceExists = 23
        ServiceAlreadyPaused = 24
        ServiceNotFound = 25
    End Enum

    '''

    ''' Gets the current start mode for the given service.
    ''' 

    '''
Name of an installed service.
    ''' Numerical code indicating the service's start mode.
    Public Shared Function GetStartMode(ByVal sService As String) As ServiceStartMode
        Dim service As ManagementObject = Nothing
        Dim sServicePath As String
        Dim sStartMode As String

        GetStartMode = ServiceStartMode.Disabled

        Try
            sServicePath = String.Format("Win32_Service.Name=""{0}""", sService)
            service = New ManagementObject(sServicePath)
            sStartMode = service.GetPropertyValue("StartMode").ToString

            'We can't return the exact property value because StartMode will
            'show as 'Auto' rather than 'Automatic'. Since the ChangeStartMode
            'WMI method will need to have 'Automatic' passed when setting the
            'service to auto-start, our ServiceStartMode enum uses 'Automatic'
            Select Case sStartMode
                Case "Boot"
                    Return ServiceStartMode.Boot
                Case "System"
                    Return ServiceStartMode.System
                Case "Auto"
                    Return ServiceStartMode.Automatic
                Case "Manual"
                    Return ServiceStartMode.Manual
                Case "Disabled"
                    Return ServiceStartMode.Disabled
            End Select
        Catch
            Throw
        Finally
            If service IsNot Nothing Then
                service.Dispose()
            End If
        End Try
    End Function

    '''

    ''' Sets the start mode for the given service.
    ''' 

    '''
Name of an installed service.
    '''
Numerical code representing the new start mode.
    ''' Error code indicating the result of the change operation.
    Public Shared Function SetStartMode(ByVal sService As String, ByVal nStartMode As ServiceStartMode) As ReturnValue
        Dim service As ManagementObject = Nothing
        Dim inParams As ManagementBaseObject = Nothing
        Dim outParams As ManagementBaseObject = Nothing
        Dim sServicePath As String

        SetStartMode = ReturnValue.UnknownFailure

        Try
            sServicePath = String.Format("Win32_Service.Name=""{0}""", sService)
            service = New ManagementObject(sServicePath)
            inParams = service.GetMethodParameters("ChangeStartMode")
            inParams("StartMode") = nStartMode.ToString()
            outParams = service.InvokeMethod("ChangeStartMode", inParams, Nothing)

            Return DirectCast([Enum].Parse(GetType(ReturnValue), outParams("ReturnValue").ToString()), ReturnValue)
        Catch
            Throw
        Finally
            If inParams IsNot Nothing Then
                inParams.Dispose()
            End If

            If outParams IsNot Nothing Then
                outParams.Dispose()
            End If

            If service IsNot Nothing Then
                service.Dispose()
            End If
        End Try
    End Function
End Class

When I tried to do the same thing with the 4.9.0 source, it failed miserably. It just wouldn’t create an instance of SqlDataProvider, no matter how much I coaxed it. The better way was to have my service download the new module files (zips) to the installmodule folder under the portal’s root, create an HttpWebRequest to http://mysite/install/install.aspx?mode=installresources, then parse the response to check for success.

The response parsing was easier than I thought it would be. I did the bulk update first using a web browser so I could see what I was dealing with. It looked something like this:

The HTML itself was nice in that it put non-blank space elements between each module name and result, so I could use Split to break everything out. I ignored the first two elements of the resultant array since it contained all the unimportant stuff before the list of modules, then simply looped over the array and verified the word Success was in each even-numbered element, like so:

Dim aResults() As String

aResults = Split(sResponse, " ")

If aResults.Length > 0 Then
    For i As Integer = 2 To aResults.Length - 1
        If i Mod 2 = 0 Then
            If Not aResults(i).Contains("Success") Then
                Return False
            End If
        End If
    Next i

    Return True
End If

I’m not sure why I had never heard of this feature over the course of developing several custom DNN modules, even though I’ve spent untold hours sifting through the forums at dotnetnuke.com and the Internet at large for detailed information on the portal’s architecture. In any case, that was the one new thing I learned that day.

It’s based on some bits of code I found on the web. Initially GetADGroupMembership would only return the first-level Active Directory groups the user was in, but that’s no good if the user is in a group that is in another group that is in yet another group that’s the one you really care about. So I added some recursion to bring up the entire group chain. It seems to perform well enough with our domain, which admittedly doesn’t have a great deal of nesting.

Imports System.DirectoryServices

Public Class LDAP
    Public Shared Function GetADGroupMembership(ByVal sPath As String, ByVal sUserID As String) As List(Of String)
        Dim lstResults As List(Of String)
        Dim lstGroups As List(Of String)
        Dim lstSubGroups As List(Of String)
        Dim sFilter As String

        GetADGroupMembership = Nothing

        sFilter = "(&(objectClass=user)(samAccountName=" & sUserID & "))"
        lstResults = RunSearch(sPath, sFilter, "MemberOf")
        lstGroups = New List(Of String)

        If lstResults IsNot Nothing Then
            For Each result As String In lstResults
                lstGroups.Add(result)
                lstSubGroups = GetADGroupMembershipByGroup(sPath, result)

                For Each sSubGroup As String In lstSubGroups
                    If Not lstGroups.Contains(sSubGroup) Then
                        lstGroups.Add(sSubGroup)
                    End If
                Next sSubGroup
            Next result
        End If

        Return lstGroups
    End Function

    Public Shared Function GetLocalGroupMembership(ByVal sPath As String, ByVal sUserName As String, ByVal sPassword As String) As List(Of String)
        Dim de As DirectoryEntry = Nothing
        Dim colGroups As Object
        Dim lstGroups As List(Of String)

        GetLocalGroupMembership = Nothing

        Try
            de = New DirectoryEntry(sPath, sUserName, sPassword, AuthenticationTypes.Secure)
            colGroups = de.Invoke("Groups")
            lstGroups = New List(Of String)

            For Each o As Object In colGroups
                lstGroups.Add(o.Name)
            Next o

            Return lstGroups
        Catch
            Throw
        Finally
            If de IsNot Nothing Then
                de.Dispose()
            End If
        End Try
    End Function

    Public Shared Function GetADGroups(ByVal sPath As String) As List(Of String)
        Dim lstGroups As List(Of String)
        Dim sFilter As String

        GetADGroups = Nothing

        sFilter = "(&(objectClass=group))"
        lstGroups = RunSearch(sPath, sFilter)
        lstGroups.Sort()

        Return lstGroups
    End Function

    Private Shared Function GetADGroupMembershipByGroup(ByVal sPath As String, ByVal sGroupName As String) As List(Of String)
        Dim lstResults As List(Of String)
        Dim lstGroups As List(Of String)
        Dim lstSubGroups As List(Of String)
        Dim sFilter As String

        GetADGroupMembershipByGroup = Nothing

        sFilter = "(&(objectCategory=group)(cn=" & sGroupName & "))"
        lstResults = RunSearch(sPath, sFilter, "MemberOf")
        lstGroups = New List(Of String)

        If lstResults IsNot Nothing Then
            For Each result As String In lstResults
                lstGroups.Add(result)

                'Retrieve all groups that the current group is a member of
                lstSubGroups = GetADGroupMembershipByGroup(sPath, result)
                For Each sSubGroup As String In lstSubGroups
                    If Not lstGroups.Contains(sSubGroup) Then
                        lstGroups.Add(sSubGroup)
                    End If
                Next sSubGroup
            Next result
        End If

        Return lstGroups
    End Function

    Private Shared Function RunSearch(ByVal sPath As String, ByVal sFilter As String, Optional ByVal sProperty As String = "") As List(Of String)
        Dim lstResults As List(Of String)
        Dim de As System.DirectoryServices.DirectoryEntry = Nothing
        Dim deSearcher As System.DirectoryServices.DirectorySearcher = Nothing
        Dim results As System.DirectoryServices.SearchResultCollection
        Dim res As System.DirectoryServices.SearchResult

        RunSearch = Nothing

        Try
            de = New System.DirectoryServices.DirectoryEntry(sPath)
            deSearcher = New System.DirectoryServices.DirectorySearcher(de)
            deSearcher.Filter = sFilter
            deSearcher.SearchScope = SearchScope.Subtree
            results = deSearcher.FindAll

            lstResults = New List(Of String)

            For Each res In results
                If sProperty = "" Then
                    'If no specific property is being sought, simply return the common name
                    lstResults.Add(TrimToName(res.GetDirectoryEntry.Name))
                Else
                    For Each o As Object In res.Properties(sProperty)
                        lstResults.Add(TrimToName(o))
                    Next o
                End If
            Next res

            Return lstResults
        Catch
            Throw
        Finally
            If deSearcher IsNot Nothing Then
                deSearcher.Dispose()
            End If

            If de IsNot Nothing Then
                de.Dispose()
            End If
        End Try
    End Function

    Private Shared Function TrimToName(ByVal path As String) As String
        Dim parts() As String

        parts = path.Split(",")
        Return parts(0).Replace("CN=", String.Empty)
    End Function
End Class

I don’t know what major new features went into SQL 2008, but I do know one big thing that changed in Management Studio and it’s not good. I present exhibit A: the activity monitor. Previous versions of SQL Server had a place where you could see all the processes running on the server. It was handy because you could quickly tell who had locks on what database, find out if there were any processes that were blocking or being blocked, and you could end a process that couldn’t be ended through natural means. Yet somehow Microsoft decided that was all too simple.

First they moved it out of the object explorer and into the context menu of the database server itself, where nobody would think to look. I had to turn to Google to determine how you open it. Then once you start it you’re greeted with one of the worst user interfaces I’ve ever seen. You have to click on the Processes pane to show processes. All the columns of information are in one fixed-width grid with no horizontal scroll bar, so if you want to widen one it will come at the expense of narrowing another. And there are 16 columns! They have filter options in the column headers that dynamically allow you to filter by values in the column, which is all well and good, but the headers are more clunky than anything else. And finally, the grid defaults to only using about a third the vertical space of the window, and that’s all you get.

In short, it’s horrible and evil. I’m amazed that they would take something that was so easy to use and make it so unpleasant. Maybe I haven’t spent enough time with it,and maybe it’s due to the fact that we have the Express version, but if it’s really no more than what I’ve seen, I pray there will be some other tools out there that can show you the same information in a much better package.